Back to index

lightning-sunbird  0.9+nobinonly
Functions
fbedgeimp.h File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

static void rasterizeEdges (FbBits *buf, int width, int stride, RenderEdge *l, RenderEdge *r, xFixed t, xFixed b)

Function Documentation

static void rasterizeEdges ( FbBits buf,
int  width,
int  stride,
RenderEdge l,
RenderEdge r,
xFixed  t,
xFixed  b 
) [static]

Definition at line 29 of file fbedgeimp.h.

{
    xFixed  y = t;
    FbBits  *line;
    
    line = buf + xFixedToInt (y) * stride;
    
    for (;;)
    {
       xFixed lx, rx;
       int    lxi, rxi;
       
       /* clip X */
       lx = l->x;
       if (lx < 0)
           lx = 0;
       rx = r->x;
       if (xFixedToInt (rx) >= width)
           rx = IntToxFixed (width);
       
       /* Skip empty (or backwards) sections */
       if (rx > lx)
       {

           /* Find pixel bounds for span. */
           lxi = xFixedToInt (lx);
           rxi = xFixedToInt (rx);

#if N_BITS == 1
           {
              FbBits  *a = line;
              FbBits  startmask, endmask;
              int        nmiddle;
              int        width = rxi - lxi;
              int        x = lxi;

              a += x >> FB_SHIFT;
              x &= FB_MASK;

              FbMaskBits (x, width, startmask, nmiddle, endmask);
              if (startmask)
                  *a++ |= startmask;
              while (nmiddle--)
                  *a++ = FB_ALLONES;
              if (endmask)
                  *a |= endmask;
           }
#else
           {
              DefineAlpha(line,lxi);
              int        lxs, rxs;

              /* Sample coverage for edge pixels */
              lxs = RenderSamplesX (lx, N_BITS);
              rxs = RenderSamplesX (rx, N_BITS);

              /* Add coverage across row */
              if (lxi == rxi)
              {
                  AddAlpha (rxs - lxs);
              }
              else
              {
                  int       xi;

                  AddAlpha (N_X_FRAC(N_BITS) - lxs);
                  StepAlpha;
                  for (xi = lxi + 1; xi < rxi; xi++)
                  {
                     AddAlpha (N_X_FRAC(N_BITS));
                     StepAlpha;
                  }
                  /* Do not add in a 0 alpha here. This check is
                   * necessary to avoid a buffer overrun, (when rx
                   * is exactly on a pixel boundary). */
                  if (rxs)
                     AddAlpha (rxs);
              }
           }
#endif
       }

       if (y == b)
           break;

#if N_BITS > 1
       if (xFixedFrac (y) != Y_FRAC_LAST(N_BITS))
       {
           RenderEdgeStepSmall (l);
           RenderEdgeStepSmall (r);
           y += STEP_Y_SMALL(N_BITS);
       }
       else
#endif
       {
           RenderEdgeStepBig (l);
           RenderEdgeStepBig (r);
           y += STEP_Y_BIG(N_BITS);
           line += stride;
       }
    }
}