Blame c++/contourgl/test.cpp

93cbac
/*
93cbac
    ......... 2015 Ivan Mahonin
93cbac
93cbac
    This program is free software: you can redistribute it and/or modify
93cbac
    it under the terms of the GNU General Public License as published by
93cbac
    the Free Software Foundation, either version 3 of the License, or
93cbac
    (at your option) any later version.
93cbac
93cbac
    This program is distributed in the hope that it will be useful,
93cbac
    but WITHOUT ANY WARRANTY; without even the implied warranty of
93cbac
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
93cbac
    GNU General Public License for more details.
93cbac
93cbac
    You should have received a copy of the GNU General Public License
93cbac
    along with this program.  If not, see <http: licenses="" www.gnu.org="">.</http:>
93cbac
*/
93cbac
93cbac
#include <fstream></fstream>
93cbac
#include <iostream></iostream>
c7fa36
#include <iomanip></iomanip>
93cbac
93cbac
#include "test.h"
93cbac
#include "contourbuilder.h"
8cd87e
#include "triangulator.h"
49e693
#include "measure.h"
49e693
#include "utils.h"
d989ab
#include "clrender.h"
93cbac
93cbac
93cbac
using namespace std;
93cbac
93cbac
d9c2d9
void Test::draw_contour(
d9c2d9
	Environment &e,
d9c2d9
	int start,
d9c2d9
	int count,
d9c2d9
	const rect<int> bounds,</int>
d9c2d9
	bool even_odd,
d9c2d9
	bool invert,
d9c2d9
	const Color &color
d9c2d9
) {
d9c2d9
	glScissor(bounds.p0.x, bounds.p0.y, bounds.p1.x-bounds.p0.x, bounds.p1.y-bounds.p0.y);
d9c2d9
	glEnable(GL_SCISSOR_TEST);
49e693
	glEnable(GL_STENCIL_TEST);
93cbac
49e693
	// render mask
a04770
	glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
49e693
	glClear(GL_STENCIL_BUFFER_BIT);
49e693
	glStencilFunc(GL_ALWAYS, 0, 0);
49e693
	if (even_odd) {
49e693
		glStencilOp(GL_INCR_WRAP, GL_INCR_WRAP, GL_INCR_WRAP);
93cbac
	} else {
49e693
		glStencilOpSeparate(GL_FRONT, GL_INCR_WRAP, GL_INCR_WRAP, GL_INCR_WRAP);
49e693
		glStencilOpSeparate(GL_BACK, GL_DECR_WRAP, GL_DECR_WRAP, GL_DECR_WRAP);
49e693
	}
49e693
	e.shaders.simple();
d9c2d9
	glDrawArrays(GL_TRIANGLE_FAN, start, count);
a04770
	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
49e693
49e693
	// fill mask
49e693
	glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
49e693
	if (!even_odd && !invert)
49e693
		glStencilFunc(GL_NOTEQUAL, 0, -1);
49e693
	if (!even_odd &&  invert)
49e693
		glStencilFunc(GL_EQUAL, 0, -1);
49e693
	if ( even_odd && !invert)
49e693
		glStencilFunc(GL_EQUAL, 1, 1);
49e693
	if ( even_odd &&  invert)
49e693
		glStencilFunc(GL_EQUAL, 0, 1);
49e693
49e693
	e.shaders.color(color);
49e693
	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
49e693
49e693
	glDisable(GL_STENCIL_TEST);
d9c2d9
	glDisable(GL_SCISSOR_TEST);
7c6b57
}
7c6b57
f29469
void Test::load(Data &contours, const std::string &filename) {
9edf2e
	vector<vector> groups;</vector>
9edf2e
	groups.push_back(Vector());
9edf2e
f29469
	ifstream f(("data/" + filename).c_str());
9edf2e
	int vertices_count = 0;
9edf2e
	while(f) {
9edf2e
		string s;
9edf2e
		f >> s;
9edf2e
		if (s == "g") {
9edf2e
			Vector t;
9edf2e
			f >> t.x >> t.y;
9edf2e
			groups.push_back(groups.back() + t);
9edf2e
		} else
9edf2e
		if (s == "end") {
9edf2e
			groups.pop_back();
9edf2e
			if ((int)groups.size() == 1)
9edf2e
				break;
9edf2e
		} else
9edf2e
		if (s == "path") {
9edf2e
			contours.push_back(ContourInfo());
9edf2e
			ContourInfo &ci = contours.back();
9edf2e
			f >> ci.invert
9edf2e
			  >> ci.antialias
9edf2e
			  >> ci.evenodd
9edf2e
			  >> ci.color.r
9edf2e
			  >> ci.color.g
9edf2e
			  >> ci.color.b
9edf2e
			  >> ci.color.a;
9edf2e
			bool closed = true;
9edf2e
			while(true) {
9edf2e
				f >> s;
9edf2e
				Vector p1;
9edf2e
				if (s == "M") {
9edf2e
					f >> p1.x >> p1.y;
9edf2e
					ci.contour.move_to(p1 + groups.back());
9edf2e
					closed = false;
9edf2e
				} else
9edf2e
				if (s == "L") {
9edf2e
					f >> p1.x >> p1.y;
9edf2e
					if (closed) {
9edf2e
						ci.contour.move_to(p1 + groups.back());
9edf2e
						closed = false;
9edf2e
					}
9edf2e
					ci.contour.line_to(p1 + groups.back());
9edf2e
				} else
9edf2e
				if (s == "Z") {
9edf2e
					ci.contour.close();
9edf2e
					closed = true;
9edf2e
				} else
9edf2e
				if (s == "end") {
9edf2e
					break;
9edf2e
				} else {
9edf2e
					cout << "bug " << s << endl;
9edf2e
					if (!f) break;
9edf2e
				}
9edf2e
			}
9edf2e
			if (!closed)
9edf2e
				ci.contour.close();
9edf2e
			if (ci.color.a < 0.9999)
9edf2e
				contours.pop_back();
9edf2e
			else
9edf2e
				vertices_count += ci.contour.get_chunks().size();
9edf2e
		} else
9edf2e
		if (s != "") {
9edf2e
			cout << "bug " << s << endl;
9edf2e
		}
9edf2e
	}
9edf2e
	if ((int)groups.size() != 1)
9edf2e
		cout << "bug groups " << groups.size() << endl;
9edf2e
9edf2e
	cout << contours.size() << " contours" << endl;
9edf2e
	cout << vertices_count << " vertices" << endl;
9edf2e
}
9edf2e
f29469
void Test::transform(Data &data, const Rect &from, const Rect &to) {
f29469
	for(Data::iterator i = data.begin(); i != data.end(); ++i)
f29469
		i->contour.transform(from, to);
f29469
}
9edf2e
f29469
void Test::downgrade(Data &from, Data &to) {
f29469
	to = from;
f29469
	Measure t("downgrade");
f29469
	for(Data::iterator i = from.begin(); i != from.end(); ++i)
d9c2d9
		i->contour.downgrade(to[i - from.begin()].contour, Vector(1.f, 1.f));
f29469
}
93cbac
f29469
void Test::split(Data &from, Data &to) {
f29469
	to = from;
f29469
	Measure t("split");
f29469
	for(Data::iterator i = from.begin(); i != from.end(); ++i)
f29469
		i->contour.split(to[i - from.begin()].contour, Rect(0.f, 0.f, 100000.f, 100000.f), Vector(1.f, 1.f));
f29469
}
93cbac
f29469
void Test::test_gl_stencil(Environment &e, Data &data) {
d9c2d9
	Vector size = Utils::get_frame_size();
7c6b57
	GLuint buffer_id = 0;
7c6b57
	GLuint array_id = 0;
a04770
	vector<vec2f> vertices;</vec2f>
f29469
	vector<int> starts(data.size());</int>
f29469
	vector<int> counts(data.size());</int>
d9c2d9
	vector< rect<int> > bounds(data.size());</int>
f29469
f29469
	vertices.push_back(vec2f(-1.f, -1.f));
f29469
	vertices.push_back(vec2f( 1.f, -1.f));
f29469
	vertices.push_back(vec2f(-1.f,  1.f));
f29469
	vertices.push_back(vec2f( 1.f,  1.f));
f29469
	for(int i = 0; i < (int)data.size(); ++i) {
f29469
		starts[i] = (int)vertices.size();
f29469
		const Contour::ChunkList &chunks = data[i].contour.get_chunks();
d9c2d9
		Rect r(chunks.front().p1, chunks.front().p1);
f29469
		for(Contour::ChunkList::const_iterator j = chunks.begin(); j != chunks.end(); ++j) {
d9c2d9
			vertices.push_back(vec2f(j->p1));
d9c2d9
			r = r.expand(j->p1);
8de121
		}
f29469
		counts[i] = (int)vertices.size() - starts[i];
d9c2d9
		bounds[i].p0.x = (int)floor((r.p0.x + 1.0)*0.5*size.x);
d9c2d9
		bounds[i].p0.y = (int)floor((r.p0.y + 1.0)*0.5*size.y);
d9c2d9
		bounds[i].p1.x = (int)ceil ((r.p1.x + 1.0)*0.5*size.x) + 1;
d9c2d9
		bounds[i].p1.y = (int)ceil ((r.p1.y + 1.0)*0.5*size.y) + 1;
8de121
	}
8de121
f29469
	glGenBuffers(1, &buffer_id);
f29469
	glBindBuffer(GL_ARRAY_BUFFER, buffer_id);
f29469
	glBufferData( GL_ARRAY_BUFFER,
f29469
				  vertices.size()*sizeof(vec2f),
f29469
				  &vertices.front(),
f29469
				  GL_DYNAMIC_DRAW );
8de121
f29469
	glGenVertexArrays(1, &array_id);
f29469
	glBindVertexArray(array_id);
93cbac
f29469
	glEnableVertexAttribArray(0);
f29469
	glVertexAttribPointer(0, 2, GL_FLOAT, GL_TRUE, 0, NULL);
6e407d
f29469
	e.shaders.color(Color(0.f, 0.f, 1.f, 1.f));
f29469
	glDrawArrays(GL_TRIANGLE_STRIP, 0, vertices.size());
f29469
	glFinish();
f29469
	glClear(GL_COLOR_BUFFER_BIT);
f29469
	glFinish();
93cbac
93cbac
	{
f29469
		Measure t("render");
f29469
		for(int i = 0; i < (int)data.size(); ++i) {
f29469
			draw_contour(
f29469
				e,
f29469
				starts[i],
f29469
				counts[i],
d9c2d9
				bounds[i],
f29469
				data[i].invert,
f29469
				data[i].evenodd,
f29469
				data[i].color );
f29469
		}
d9c2d9
		glFinish();
93cbac
	}
93cbac
}
93cbac
f29469
void Test::test_sw(Environment &e, Data &data, Surface &surface) {
f29469
	vector<polyspan> polyspans(data.size());</polyspan>
93cbac
	{
f29469
		Measure t("polyspans");
f29469
		for(int i = 0; i < (int)data.size(); ++i) {
f29469
			polyspans[i].init(0, 0, surface.width, surface.height);
f29469
			data[i].contour.to_polyspan(polyspans[i]);
f29469
			polyspans[i].sort_marks();
f29469
		}
93cbac
	}
93cbac
93cbac
	{
f29469
		Measure t("render");
f29469
		for(int i = 0; i < (int)data.size(); ++i)
f29469
			SwRender::polyspan(surface, polyspans[i], data[i].color, data[i].evenodd, data[i].invert);
93cbac
	}
93cbac
}
93cbac
f29469
void Test::test_cl(Environment &e, Data &data, Surface &surface) {
013f0c
	// prepare data
013f0c
013f0c
	vector<char> paths(sizeof(int));</char>
013f0c
	int count = 0;
013f0c
	for(Data::const_iterator i = data.begin(); i != data.end(); ++i)
013f0c
		if (int points_count = i->contour.get_chunks().size()) {
013f0c
			++count;
013f0c
013f0c
			int flags = 0;
013f0c
			if (i->invert)  flags |= 1;
013f0c
			if (i->evenodd) flags |= 2;
013f0c
013f0c
			size_t s = paths.size();
013f0c
			paths.resize(paths.size() + sizeof(int) + sizeof(int) + sizeof(Color) + (points_count+1)*sizeof(vec2f));
013f0c
013f0c
			*(int*)&paths[s] = points_count+1; s += sizeof(int);
013f0c
			*(int*)&paths[s] = flags;          s += sizeof(int);
013f0c
			*(Color*)&paths[s] = i->color;     s += sizeof(Color);
013f0c
			vec2f *point = (vec2f*)&paths[s];
013f0c
013f0c
			for(Contour::ChunkList::const_iterator j = i->contour.get_chunks().begin(); j != i->contour.get_chunks().end(); ++j, ++point)
013f0c
				*point = vec2f(j->p1);
013f0c
			*point = vec2f(i->contour.get_chunks().front().p1);
2d0519
		}
013f0c
	*(int*)&paths.front() = count;
013f0c
013f0c
	// draw
9edf2e
f29469
	ClRender clr(e.cl);
f29469
	clr.send_surface(&surface);
d989ab
2517eb
	// warm-up
2517eb
	//clr.send_paths(&paths.front(), paths.size());
2517eb
	//for(int i = 0; i < 1000; ++i)
2517eb
	//	clr.draw();
2517eb
	clr.remove_paths();
2517eb
2517eb
	// actual task
2517eb
	clr.send_surface(&surface);
d989ab
	{
f29469
		Measure t("render");
013f0c
		clr.send_paths(&paths.front(), paths.size());
013f0c
		clr.draw();
f29469
		clr.wait();
c7fa36
	}
f29469
	clr.receive_surface();
9edf2e
}
b09c5d
b09c5d
void Test::test_cl2(Environment &e, Data &data, Surface &surface) {
b09c5d
	// prepare data
b09c5d
b09c5d
	vector<clrender2::path> paths;</clrender2::path>
b09c5d
	vector<clrender2::point> points;</clrender2::point>
b09c5d
	paths.reserve(data.size());
b09c5d
	for(Data::const_iterator i = data.begin(); i != data.end(); ++i)
b09c5d
		if (int points_count = i->contour.get_chunks().size()) {
b09c5d
			ClRender2::Path path;
b09c5d
			path.color = i->color;
b09c5d
			path.invert  = i->invert  ? -1 : 0;
b09c5d
			path.evenodd = i->evenodd ? -1 : 0;
b09c5d
			path.align0 = 0;
b09c5d
			path.align1 = 0;
b09c5d
			paths.push_back(path);
b09c5d
b09c5d
			int first_point_index = (int)points.size();
b09c5d
			int path_index = (int)paths.size() - 1;
b09c5d
			points.reserve(points.size() + points_count + 1);
b09c5d
			for(Contour::ChunkList::const_iterator j = i->contour.get_chunks().begin(); j != i->contour.get_chunks().end(); ++j) {
b09c5d
				ClRender2::Point point;
b09c5d
				point.coord = vec2f(j->p1);
b09c5d
				point.path_index = path_index;
b09c5d
				point.align0 = 0;
b09c5d
				points.push_back(point);
b09c5d
			}
b09c5d
			points.push_back(points[first_point_index]);
b09c5d
		}
b09c5d
b09c5d
	// draw
b09c5d
b09c5d
	ClRender2 clr(e.cl);
b09c5d
b09c5d
	// warm-up
b09c5d
	{
b09c5d
	//clr.send_surface(&surface);
b09c5d
	//clr.send_paths(&paths.front(), (int)paths.size(), &points.front(), (int)points.size());
b09c5d
	//for(int i = 0; i < 1000; ++i)
b09c5d
	//	clr.draw(), clr.wait();
b09c5d
	//clr.remove_paths();
b09c5d
	}
b09c5d
b09c5d
	// actual task
b09c5d
	clr.send_surface(&surface);
b09c5d
	clr.send_paths(&paths.front(), (int)paths.size(), &points.front(), (int)points.size());
b09c5d
	{
b09c5d
		Measure t("render");
b09c5d
		clr.draw();
b09c5d
		clr.wait();
b09c5d
	}
b09c5d
	clr.receive_surface();
b09c5d
}
105dfe
105dfe
void Test::test_cl3(Environment &e, Data &data, Surface &surface) {
105dfe
	// prepare data
105dfe
	vector<clrender3::path> paths;</clrender3::path>
105dfe
	vector<vec2f> points;</vec2f>
105dfe
	paths.reserve(data.size());
105dfe
	for(Data::const_iterator i = data.begin(); i != data.end(); ++i) {
105dfe
		if (!i->contour.get_chunks().empty()) {
105dfe
			ClRender3::Path path = {};
105dfe
			path.color = i->color;
105dfe
			path.invert = i->invert;
105dfe
			path.evenodd = i->evenodd;
105dfe
f14ea7
			path.bounds.minx = path.bounds.maxx = (int)floor(i->contour.get_chunks().front().p1.x);
f14ea7
			path.bounds.miny = path.bounds.maxy = (int)floor(i->contour.get_chunks().front().p1.y);
105dfe
			path.begin = (int)points.size();
105dfe
			points.reserve(points.size() + i->contour.get_chunks().size() + 1);
105dfe
			for(Contour::ChunkList::const_iterator j = i->contour.get_chunks().begin(); j != i->contour.get_chunks().end(); ++j) {
f14ea7
				int x = (int)floor(j->p1.x);
105dfe
				int y = (int)floor(j->p1.y);
f14ea7
				if (path.bounds.minx > x) path.bounds.minx = x;
f14ea7
				if (path.bounds.maxx < x) path.bounds.maxx = x;
f14ea7
				if (path.bounds.miny > y) path.bounds.miny = y;
f14ea7
				if (path.bounds.maxy < y) path.bounds.maxy = y;
105dfe
				points.push_back(vec2f(j->p1));
105dfe
			}
105dfe
			path.end = (int)points.size();
105dfe
			points.push_back( points[path.begin] );
f14ea7
			++path.bounds.maxx;
f14ea7
			++path.bounds.maxy;
105dfe
105dfe
			paths.push_back(path);
105dfe
		}
105dfe
	}
105dfe
105dfe
	// draw
105dfe
105dfe
	ClRender3 clr(e.cl);
105dfe
105dfe
	// warm-up
82f284
	clr.send_surface(&surface);
82f284
	clr.send_points(&points.front(), (int)points.size());
82f284
	for(int ii = 0; ii < 1000; ++ii)
82f284
		for(vector<clrender3::path>::const_iterator i = paths.begin(); i != paths.end(); ++i)</clrender3::path>
82f284
			clr.draw(*i);
82f284
	clr.wait();
105dfe
105dfe
	// measure
82f284
	{
82f284
		for(int ii = 0; ii < 1000; ++ii) {
82f284
			Measure t("render", false, true);
105dfe
			for(vector<clrender3::path>::const_iterator i = paths.begin(); i != paths.end(); ++i)</clrender3::path>
105dfe
				clr.draw(*i);
82f284
			clr.wait();
82f284
		}
82f284
	}
82f284
	clr.send_points(NULL, 0);
82f284
	clr.send_surface(NULL);
105dfe
105dfe
	// actual task
105dfe
	clr.send_surface(&surface);
105dfe
	clr.send_points(&points.front(), (int)points.size());
105dfe
	{
105dfe
		for(vector<clrender3::path>::const_iterator i = paths.begin(); i != paths.end(); ++i)</clrender3::path>
105dfe
			clr.draw(*i);
105dfe
		clr.wait();
105dfe
	}
105dfe
	clr.receive_surface();
105dfe
}