/*

    ......... 2015 Ivan Mahonin

    This program is free software: you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation, either version 3 of the License, or

    (at your option) any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

#include "swrender.h"

using namespace std;

void SwRender::fill(

	Surface &target,

	const Color &color )

{

	for(Color *i = target.data, *end = i + target.count(); i != end; ++i)

		*i = color;

}

void SwRender::fill(

	Surface &target,

	const Color &color,

	int left,

	int top,

	int width,

	int height )

{

	int step = target.width - width;

	for(Color *i = &target[top][left], *end = i + height*target.width; i < end; i += step)

		for(Color *rowend = i + width; i < rowend; ++i)

			*i = color;

}

void SwRender::row(

	Surface &target,

	const Color &color,

	int left,

	int top,

	int length )

{

	for(Color *i = &target[top][left], *end = i + length; i < end; ++i)

		*i = color;

}

void SwRender::row_alpha(

	Surface &target,

	const Color &color,

	Color::type alpha,

	int left,

	int top,

	int length )

{

	for(Color *i = &target[top][left], *end = i + length; i < end; ++i) {

		i->r = i->r*(1.f - alpha) + color.r*alpha;

		i->g = i->g*(1.f - alpha) + color.g*alpha;

		i->b = i->b*(1.f - alpha) + color.b*alpha;

		i->a = i->a*(1.f - alpha) + color.a*alpha;

	}

}

void SwRender::polyspan(

	Surface &target,

	const Polyspan &polyspan,

	const Color &color,

	bool evenodd,

	bool invert )

{

	const ContextRect &window = polyspan.get_window();

	const Polyspan::cover_array &covers = polyspan.get_covers();

	Polyspan::cover_array::const_iterator cur_mark = covers.begin();

	Polyspan::cover_array::const_iterator end_mark = covers.end();

	Real cover = 0, area = 0, alpha = 0;

	int	y = 0, x = 0;

	if (cur_mark == end_mark) {

		// no marks at all

		if (invert)

			fill( target, color,

				  window.minx, window.miny,

				  window.maxx - window.minx, window.maxy - window.miny );

		return;

	}

	// fill initial rect / line

	if (invert) {

		// fill all the area above the first vertex

		y = window.miny;

		int l = window.maxx - window.minx;

		fill( target, color,

			  window.minx, window.miny,

			  l, cur_mark->y - window.miny );

		// fill the area to the left of the first vertex on that line

		l = cur_mark->x - window.minx;

		if (l)

			row(target, color, window.minx, cur_mark->y, l);

	}

	while(true) {

		y = cur_mark->y;

		x = cur_mark->x;

		area = cur_mark->area;

		cover += cur_mark->cover;

		// accumulate for the current pixel

		while(++cur_mark != covers.end()) {

			if (y != cur_mark->y || x != cur_mark->x)

				break;

			area += cur_mark->area;

			cover += cur_mark->cover;

		}

		// draw pixel - based on covered area

		if (area) { // if we're ok, draw the current pixel

			alpha = polyspan.extract_alpha(cover - area, evenodd);

			if (invert) alpha = 1 - alpha;

			if (alpha) {

				Color::type a = (Color::type)alpha;

				Color &c = target[y][x];

				c.r = c.r*(1.f - a) + color.r*a;

				c.g = c.g*(1.f - a) + color.g*a;

				c.b = c.b*(1.f - a) + color.b*a;

				c.a = c.a*(1.f - a) + color.a*a;

			}

			++x;

		}

		// if we're done, don't use iterator and exit

		if (cur_mark == end_mark)

			break;

		// if there is no more live pixels on this line, goto next

		if (y != cur_mark->y) {

			if (invert) {

				// fill the area at the end of the line

				row(target, color, x, y, window.maxx - x);

				// fill area at the beginning of the next line

				row(target, color, window.minx, cur_mark->y, cur_mark->x - window.minx);

			}

			cover = 0;

			continue;

		}

		// draw span to next pixel - based on total amount of pixel cover

		if (x < cur_mark->x) {

			alpha = polyspan.extract_alpha(cover, evenodd);

			if (invert) alpha = 1.0 - alpha;

			if (alpha)

				row_alpha(target, color, alpha, x, y, cur_mark->x - x);

		}

	}

	// fill the after stuff

	if (invert) {

		// fill the area at the end of the line

		row(target, color, x, y, window.maxx - x);

		// fill area at the beginning of the next line

		fill( target, color,

			  window.minx, y+1,

			  window.maxx - window.minx, window.maxy - y - 1 );

	}

}