ultimatepp/uppsrc/Painter/Render.cpp

#include "Painter.h"
#include "Fillers.h"

NAMESPACE_UPP

void BufferPainter::ClearOp(const RGBA& color)
{
	UPP::Fill(~ib, color, ib.GetLength());
}

Buffer<ClipLine> BufferPainter::RenderPath(double width, SpanSource *ss, const RGBA& color)
{
	Buffer<ClipLine> newclip;
	if(width == 0)
		return newclip;
	Transformer trans(pathattr.mtx);
	trans.target = &rasterizer;
	LinearPathConsumer *g;
	Stroker stroker;
	Dasher dasher;
	bool evenodd = pathattr.evenodd;
	if(width > 0) {
		stroker.Init(width, pathattr.miter_limit, pathattr.tolerance, pathattr.cap, pathattr.join);
		stroker.target = &trans;
		if(pathattr.dash.GetCount()) {
			dasher.Init(pathattr.dash, pathattr.dash_start);
			dasher.target = &stroker;
			g = &dasher;
		}
		else
			g = &stroker;
		evenodd = false;
	}
	else {
		Close();
		g = &trans;
	}
	byte *data = path.data;
	int opacity = int(256 * pathattr.opacity);
	Pointf pos = Pointf(0, 0);
	int i = 0;
	Rasterizer::Filler *rg;
	SpanFiller          span_filler;
	SolidFiller         solid_filler;
	SubpixelFiller      subpixel_filler;
	ClipFiller          clip_filler(render_cx);
	NoAAFillerFilter    noaa_filler;
	MaskFillerFilter    mf;
	bool doclip = width == -2;
	subpixel_filler.sbuffer = subpixel;
	if(doclip) {
		rg = &clip_filler;
		newclip.Alloc(ib.GetHeight());
	}
	else
	if(ss) {
		if(!span)
			span.Alloc(ib.GetWidth() + 3);
		if(subpixel) {
			subpixel_filler.ss = ss;
			subpixel_filler.buffer = span;
			subpixel_filler.alpha = opacity;
			rg = &subpixel_filler;
		}
		else {
			span_filler.ss = ss;
			span_filler.buffer = span;
			span_filler.alpha = opacity;
			rg = &span_filler;
		}
	}
	else {
		if(subpixel) {
			subpixel_filler.color = Mul8(color, opacity);
			subpixel_filler.ss = NULL;
			rg = &subpixel_filler;
		}
		else {
			solid_filler.c = Mul8(color, opacity);
			rg = &solid_filler;
		}
	}
	if(mode == MODE_NOAA) {
		noaa_filler.Set(rg);
		rg = &noaa_filler;
	}
	for(;;) {
		if(i >= path.type.GetCount() || path.type[i] == DIV) {
			g->End();
			for(int y = rasterizer.MinY(); y <= rasterizer.MaxY(); y++) {
				solid_filler.t = subpixel_filler.t = span_filler.t = ib[y];
				subpixel_filler.end = subpixel_filler.t + ib.GetWidth();
				span_filler.y = subpixel_filler.y = y;
				Rasterizer::Filler *rf = rg;
				if(clip.GetCount()) {
					const ClipLine& s = clip.Top()[y];
					if(s.IsEmpty()) goto empty;
					if(!s.IsFull()) {
						mf.Set(rg, s);
						rf = &mf;
					}
				}
				if(doclip)
					clip_filler.Clear();
				rasterizer.Render(y, *rf, evenodd);
				if(doclip)
					clip_filler.Finish(newclip[y]);
			empty:;
			}
			rasterizer.Reset();
			if(i >= path.type.GetCount())
				break;
		}
		else
		switch(path.type[i]) {
		case MOVE: {
			const LinearData *d = (LinearData *)data;
			data += sizeof(LinearData);
			g->Move(pos = d->p);
			break;
		}
		case LINE: {
			const LinearData *d = (LinearData *)data;
			data += sizeof(LinearData);
			g->Line(pos = d->p);
			break;
		}
		case QUADRATIC: {
			const QuadraticData *d = (QuadraticData *)data;
			data += sizeof(QuadraticData);
			ApproximateQuadratic(*g, pos, d->p1, d->p, pathattr.tolerance);
			pos = d->p;
			break;
		}
		case CUBIC: {
			const CubicData *d = (CubicData *)data;
			data += sizeof(CubicData);
			ApproximateCubic(*g, pos, d->p1, d->p2, d->p, pathattr.tolerance);
			pos = d->p;
			break;
		}
		default:
			NEVER();
			return newclip;
		}
		i++;
	}
	current = Null;
	return newclip;
}

void BufferPainter::FillOp(const RGBA& color)
{
	RenderPath(-1, NULL, color);
}

void BufferPainter::StrokeOp(double width, const RGBA& color)
{
	RenderPath(width, NULL, color);
}

void BufferPainter::ClipOp()
{
	Buffer<ClipLine> newclip = RenderPath(-2, NULL, RGBAZero());
	if(attr.hasclip)
		clip.Top() = newclip;
	else {
		clip.Add() = newclip;
		attr.hasclip = true;
		attr.cliplevel = clip.GetCount();
	}
}

END_UPP_NAMESPACE