renderer_scanline rasterizer_scanline

1. First of all, I implemented hline() and vline()
with alpha-blending (thanks Eric). There're overloaded
functions with one more argument 'alpha'. The reasons
to do so are that it's more convinient to have
separate RGBA and additional alpha. The latest plays
role of the 'coverage' value when rendering
anti-aliased polygons. Besides, calculations of colors
in this case are a little bit more accurate. hline()
and vline() now correspond with pixel() that also has
two versions - with and without alpha. 
If you need to use only agg::rgba8::a simply pass 255
in the last argument of hline() and vline().


2. It allowed me to implement new renderer,
agg::renderer_scanline_solid<> (file
agg_renderer_scanline.h) that can be used to draw any
anti-aliased polygons filled with solid colors. On
thin lines the performance is the same as
agg::renderer_scanline<> but it's about 30% faster
when drawing solid opaque polygons (which is very
common case). It has only one template argument
<PixelRenderer> so, it cannot be used to render
gradients, images, and Gouraud. To use this renderer
simply replace 

agg::renderer_scanline<agg::span_solid_rgba8, 
                       agg::pixfmt_rgba32> 
to

agg::renderer_scanline_solid<agg::pixfmt_rgba32>

3. I moved scanline container objects from
agg::rasterizer_scanline_aa to renderers. The reason
is that in general the rasterizer's logic doesn't
depend on the scanline while renderers do. Now
there're 5 scanline renderers implemented in
agg_renderer_scanline.h:

renderer_scanline_ex
renderer_scanline
renderer_scanline_solid
renderer_scanline_bin
renderer_scanline_bin_solid

Two latest ones use agg::scanline_bin that allows to
render non-anti-aliased polygons.
renderer_scanline_solid uses agg::scanline_p8. 
renderer_scanline uses agg::scanline_u8. 
renderer_scanline_ex allows you to use an external
scanline and basically dedicated to work with
alpha-masking and agg::scanline_u8_am (reminding that
alpha-mask can be used in addition to any span
renderer, including image transformations). 

Practically it means that you have to remove the first
template argument from the declaration of
agg::rasterizer_scanline_aa, i.e. use 
agg::rasterizer_scanline_aa<> instead of
agg::rasterizer_scanline_aa<agg::scanline_u8> or
agg::rasterizer_scanline_aa<agg::gamma8> instead of
agg::rasterizer_scanline_aa<agg::scanline_u8,
agg::gamma8>

It also affected the declarations of alpha-masking,
now you need to declare:

agg::rendering_buffer alpha_mask_rbuf;
agg::alpha_mask_gray8 alpha_mask(alpha_mask_rbuf);
typedef agg::scanline_u8_am<agg::alpha_mask_gray8>
    scanline_type;
typedef agg::renderer_scanline_ex<
    scanline_type,
    agg::span_solid_rgba8,
    agg::pixfmt_bgr24> renderer;
scanline_type sl(alpha_mask);
renderer r(rbuf_window(), sl);


i.e. use agg::renderer_scanline_ex<> with 3 template
arguments. 

4. New example graph_test that is written to test the
performance of the whole thing in different conditions
(thin lines, thin curves, dashed lines). It separately
tests different phases of the drawing:
- pipeline converters
- rasterizer::add_path
- rasterizer::sort (I added this method for tesing
purposes)
- rendering
- total time

Some resuls are in the attached text file. I used P-IV
1.9, MSVC 6.0 with default optimizations.