Blame c++/contourgl/clrender.cpp

572d9c
/*
572d9c
    ......... 2015 Ivan Mahonin
572d9c
572d9c
    This program is free software: you can redistribute it and/or modify
572d9c
    it under the terms of the GNU General Public License as published by
572d9c
    the Free Software Foundation, either version 3 of the License, or
572d9c
    (at your option) any later version.
572d9c
572d9c
    This program is distributed in the hope that it will be useful,
572d9c
    but WITHOUT ANY WARRANTY; without even the implied warranty of
572d9c
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
572d9c
    GNU General Public License for more details.
572d9c
572d9c
    You should have received a copy of the GNU General Public License
572d9c
    along with this program.  If not, see <http: licenses="" www.gnu.org="">.</http:>
572d9c
*/
572d9c
f83e6b
#include <cassert></cassert>
f83e6b
f83e6b
#include <algorithm></algorithm>
6b0407
#include <iostream></iostream>
f83e6b
572d9c
#include "clrender.h"
f83e6b
#include "measure.h"
572d9c
572d9c
572d9c
using namespace std;
572d9c
572d9c
f83e6b
ClRender::ClRender(ClContext &cl):
f83e6b
	cl(cl),
f83e6b
	contour_program(),
013f0c
	contour_draw_kernel(),
2517eb
	contour_draw_workgroup_size(),
f83e6b
	surface(),
013f0c
	paths_buffer(),
f83e6b
	mark_buffer(),
67876c
	surface_image(),
c7fa36
	prev_event()
f83e6b
{
b09c5d
	contour_program = cl.load_program("contour-fs.cl");
2517eb
	assert(contour_program);
2517eb
013f0c
	contour_draw_kernel = clCreateKernel(contour_program, "draw", NULL);
013f0c
	assert(contour_draw_kernel);
2517eb
2517eb
	cl.err |= clGetKernelWorkGroupInfo(
2517eb
		contour_draw_kernel,
2517eb
		cl.device,
2517eb
		CL_KERNEL_WORK_GROUP_SIZE,
2517eb
		sizeof(contour_draw_workgroup_size),
2517eb
		&contour_draw_workgroup_size,
2517eb
		NULL );
2517eb
	assert(!cl.err);
572d9c
}
572d9c
572d9c
ClRender::~ClRender() {
f83e6b
	send_surface(NULL);
013f0c
	send_paths(NULL, 0);
013f0c
	clReleaseKernel(contour_draw_kernel);
f83e6b
	clReleaseProgram(contour_program);
f83e6b
}
f83e6b
f83e6b
void ClRender::send_surface(Surface *surface) {
c7fa36
	if (!surface && !this->surface) return;
f83e6b
c7fa36
	cl.err |= clFinish(cl.queue);
5890eb
	assert(!cl.err);
c7fa36
	prev_event = NULL;
f83e6b
f83e6b
	if (this->surface) {
f83e6b
		clReleaseMemObject(mark_buffer);
67876c
		clReleaseMemObject(surface_image);
f83e6b
	}
f83e6b
f83e6b
	this->surface = surface;
f83e6b
f83e6b
	if (this->surface) {
5890eb
		//Measure t("ClRender::send_surface");
f83e6b
f83e6b
		mark_buffer = clCreateBuffer(
f83e6b
			cl.context, CL_MEM_READ_WRITE,
2517eb
			(surface->count() + 2)*sizeof(cl_int2), NULL,
2517eb
			&cl.err );
2517eb
		assert(!cl.err);
f83e6b
		assert(mark_buffer);
f83e6b
2517eb
		char zero = 0;
2517eb
		cl.err |= clEnqueueFillBuffer(
2517eb
			cl.queue, mark_buffer,
2517eb
			&zero, 1,
2517eb
			0, surface->count()*sizeof(cl_int2),
c7fa36
			0, NULL, NULL );
c7fa36
		assert(!cl.err);
c7fa36
2517eb
		surface_image = clCreateBuffer(
2517eb
			cl.context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR,
2517eb
			surface->count()*sizeof(Color), surface->data,
2517eb
			&cl.err );
2517eb
		assert(!cl.err);
2517eb
		assert(surface_image);
2517eb
2517eb
		cl.err |= clSetKernelArg(contour_draw_kernel, 0, sizeof(surface->width), &surface->width);
2517eb
		cl.err |= clSetKernelArg(contour_draw_kernel, 1, sizeof(surface->width), &surface->height);
2517eb
		cl.err |= clSetKernelArg(contour_draw_kernel, 2, sizeof(mark_buffer), &mark_buffer);
013f0c
		cl.err |= clSetKernelArg(contour_draw_kernel, 3, sizeof(surface_image), &surface_image);
c7fa36
		assert(!cl.err);
f83e6b
c7fa36
		cl.err |= clFinish(cl.queue);
5890eb
		assert(!cl.err);
f83e6b
	}
f83e6b
}
f83e6b
f83e6b
Surface* ClRender::receive_surface() {
f83e6b
	if (surface) {
5890eb
		//Measure t("ClRender::receive_surface");
f83e6b
2517eb
		cl.err |= clEnqueueReadBuffer(
c7fa36
			cl.queue, surface_image, CL_FALSE,
2517eb
			0, surface->count()*sizeof(Color), surface->data,
6b0407
			prev_event ? 1 : 0,
6b0407
			prev_event ? &prev_event : NULL,
6b0407
			NULL );
5890eb
		assert(!cl.err);
c7fa36
c7fa36
		cl.err |= clFinish(cl.queue);
c7fa36
		assert(!cl.err);
028154
		prev_event = NULL;
f83e6b
	}
f83e6b
	return surface;
572d9c
}
572d9c
2517eb
void ClRender::remove_paths() {
013f0c
	if (paths_buffer) {
2517eb
		cl.err |= clFinish(cl.queue);
2517eb
		assert(!cl.err);
2517eb
		prev_event = NULL;
2517eb
013f0c
		clReleaseMemObject(paths_buffer);
013f0c
		paths_buffer = NULL;
f83e6b
	}
2517eb
}
2517eb
2517eb
void ClRender::send_paths(const void *paths, int size) {
2517eb
	if (!paths_buffer && (!paths || size <= 0)) return;
2517eb
2517eb
	remove_paths();
f83e6b
013f0c
	if (paths && size > 0) {
c7fa36
		//Measure t("ClRender::send_path");
f83e6b
013f0c
		paths_buffer = clCreateBuffer(
2517eb
			cl.context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
2517eb
			size, const_cast<void*>(paths),</void*>
2517eb
			&cl.err );
5890eb
		assert(!cl.err);
2517eb
		assert(paths_buffer);
f83e6b
2517eb
		cl.err |= clSetKernelArg(contour_draw_kernel, 4, sizeof(paths_buffer), &paths_buffer);
5890eb
		assert(!cl.err);
c7fa36
	}
c7fa36
}
f83e6b
013f0c
void ClRender::draw() {
c7fa36
	//Measure t("ClRender::contour");
f83e6b
013f0c
	cl_event event = prev_event;
2517eb
	size_t count = contour_draw_workgroup_size;
b09c5d
	size_t group_size = count;
c7fa36
	cl.err |= clEnqueueNDRangeKernel(
c7fa36
		cl.queue,
013f0c
		contour_draw_kernel,
c7fa36
		1,
2517eb
		NULL,
2517eb
		&count,
b09c5d
		&group_size,
013f0c
		event ? 1 : 0,
013f0c
		event ? &event : NULL,
c7fa36
		&prev_event );
c7fa36
	assert(!cl.err);
572d9c
}
572d9c
f29469
void ClRender::wait() {
f29469
	if (prev_event) {
013f0c
		cl.err |= clWaitForEvents(1, &prev_event);
013f0c
		assert(!cl.err);
f29469
		prev_event = NULL;
f29469
	}
f29469
}
572d9c
b09c5d
b09c5d
// ------------------------------------------------
b09c5d
b09c5d
b09c5d
ClRender2::ClRender2(ClContext &cl):
b09c5d
	cl(cl),
b09c5d
	contour_program(),
b09c5d
	contour_reset_kernel(),
b09c5d
	contour_paths_kernel(),
b09c5d
	contour_draw_kernel(),
b09c5d
	surface(),
b09c5d
	points_count(),
b09c5d
	paths_buffer(),
b09c5d
	points_buffer(),
b09c5d
	samples_buffer(),
b09c5d
	surface_image(),
b09c5d
	prev_event()
b09c5d
{
b09c5d
	contour_program = cl.load_program("contour-sort.cl");
b09c5d
	assert(contour_program);
b09c5d
b09c5d
	contour_reset_kernel = clCreateKernel(contour_program, "reset", &cl.err);
b09c5d
	assert(!cl.err);
b09c5d
	assert(contour_reset_kernel);
b09c5d
b09c5d
	contour_paths_kernel = clCreateKernel(contour_program, "paths", &cl.err);
b09c5d
	assert(!cl.err);
b09c5d
	assert(contour_paths_kernel);
b09c5d
b09c5d
	contour_draw_kernel = clCreateKernel(contour_program, "draw", &cl.err);
b09c5d
	assert(!cl.err);
b09c5d
	assert(contour_draw_kernel);
b09c5d
b09c5d
	samples_buffer = clCreateBuffer(
b09c5d
		cl.context, CL_MEM_READ_WRITE,
b09c5d
		1024*1024*1024, NULL,
b09c5d
		&cl.err );
b09c5d
	assert(!cl.err);
b09c5d
	assert(samples_buffer);
b09c5d
b09c5d
	cl.err |= clSetKernelArg(contour_reset_kernel, 0, sizeof(samples_buffer), &samples_buffer);
b09c5d
	cl.err |= clSetKernelArg(contour_paths_kernel, 2, sizeof(samples_buffer), &samples_buffer);
b09c5d
	cl.err |= clSetKernelArg(contour_draw_kernel, 2, sizeof(samples_buffer), &samples_buffer);
b09c5d
	assert(!cl.err);
b09c5d
}
b09c5d
b09c5d
ClRender2::~ClRender2() {
b09c5d
	remove_paths();
b09c5d
	remove_surface();
b09c5d
b09c5d
	cl.err |= clReleaseMemObject(samples_buffer);
b09c5d
	assert(!cl.err);
b09c5d
	samples_buffer = NULL;
b09c5d
b09c5d
	clReleaseKernel(contour_reset_kernel);
b09c5d
	clReleaseKernel(contour_paths_kernel);
b09c5d
	clReleaseKernel(contour_draw_kernel);
b09c5d
	clReleaseProgram(contour_program);
b09c5d
}
b09c5d
b09c5d
void ClRender2::remove_surface() {
b09c5d
	wait();
b09c5d
b09c5d
	if (surface) {
b09c5d
		cl.err |= clReleaseMemObject(surface_image);
b09c5d
		assert(!cl.err);
b09c5d
		surface = NULL;
b09c5d
	}
b09c5d
}
b09c5d
b09c5d
void ClRender2::send_surface(Surface *surface) {
b09c5d
	if (!surface && !this->surface) return;
b09c5d
b09c5d
	remove_surface();
b09c5d
b09c5d
	assert(surface);
b09c5d
	this->surface = surface;
b09c5d
b09c5d
	//Measure t("ClRender::send_surface");
b09c5d
b09c5d
	surface_image = clCreateBuffer(
b09c5d
		cl.context, CL_MEM_READ_WRITE,
b09c5d
		surface->count()*sizeof(Color), NULL,
b09c5d
		&cl.err );
b09c5d
	assert(!cl.err);
b09c5d
	assert(surface_image);
b09c5d
b09c5d
	cl.err |= clEnqueueWriteBuffer(
b09c5d
		cl.queue, surface_image, false,
b09c5d
		0, surface->count()*sizeof(Color), surface->data,
b09c5d
		0, NULL, NULL );
b09c5d
	assert(!cl.err);
b09c5d
b09c5d
	cl.err |= clSetKernelArg(contour_paths_kernel, 0, sizeof(surface->width), &surface->width);
b09c5d
	cl.err |= clSetKernelArg(contour_paths_kernel, 1, sizeof(surface->height), &surface->height);
b09c5d
	cl.err |= clSetKernelArg(contour_draw_kernel, 0, sizeof(surface->width), &surface->width);
b09c5d
	cl.err |= clSetKernelArg(contour_draw_kernel, 1, sizeof(surface_image), &surface_image);
b09c5d
	assert(!cl.err);
b09c5d
}
b09c5d
b09c5d
Surface* ClRender2::receive_surface() {
b09c5d
	if (surface) {
b09c5d
		//Measure t("ClRender::receive_surface");
b09c5d
b09c5d
		cl.err |= clEnqueueReadBuffer(
b09c5d
			cl.queue, surface_image, CL_FALSE,
b09c5d
			0, surface->count()*sizeof(Color), surface->data,
b09c5d
			prev_event ? 1 : 0,
b09c5d
			prev_event ? &prev_event : NULL,
b09c5d
			NULL );
b09c5d
		assert(!cl.err);
b09c5d
b09c5d
		wait();
b09c5d
	}
b09c5d
	return surface;
b09c5d
}
b09c5d
b09c5d
void ClRender2::remove_paths() {
b09c5d
	wait();
b09c5d
b09c5d
	if (paths_buffer) {
b09c5d
		cl.err |= clReleaseMemObject(paths_buffer);
b09c5d
		assert(!cl.err);
b09c5d
		paths_buffer = NULL;
b09c5d
	}
b09c5d
b09c5d
	if (points_buffer) {
b09c5d
		cl.err |= clReleaseMemObject(points_buffer);
b09c5d
		assert(!cl.err);
b09c5d
		points_buffer = NULL;
b09c5d
		points_count = 0;
b09c5d
	}
b09c5d
}
b09c5d
b09c5d
void ClRender2::send_paths(const Path *paths, int paths_count, const Point *points, int points_count) {
b09c5d
	remove_paths();
b09c5d
b09c5d
	assert(paths);
b09c5d
	assert(paths_count > 0);
b09c5d
b09c5d
	assert(points);
b09c5d
	assert(points_count > 0);
b09c5d
b09c5d
	paths_buffer = clCreateBuffer(
b09c5d
		cl.context, CL_MEM_READ_ONLY,
b09c5d
		paths_count*sizeof(Path), NULL,
b09c5d
		&cl.err );
b09c5d
	assert(!cl.err);
b09c5d
	assert(paths_buffer);
b09c5d
b09c5d
	cl.err |= clEnqueueWriteBuffer(
b09c5d
		cl.queue, paths_buffer, false,
b09c5d
		0, paths_count*sizeof(Path), paths,
b09c5d
		0, NULL, NULL );
b09c5d
	assert(!cl.err);
b09c5d
b09c5d
	points_buffer = clCreateBuffer(
b09c5d
		cl.context, CL_MEM_READ_ONLY,
b09c5d
		points_count*sizeof(Point), NULL,
b09c5d
		&cl.err );
b09c5d
	assert(!cl.err);
b09c5d
	assert(points_buffer);
b09c5d
	this->points_count = points_count;
b09c5d
b09c5d
	cl.err |= clEnqueueWriteBuffer(
b09c5d
		cl.queue, points_buffer, false,
b09c5d
		0, points_count*sizeof(Point), points,
b09c5d
		0, NULL, NULL );
b09c5d
	assert(!cl.err);
b09c5d
b09c5d
	cl.err |= clSetKernelArg(contour_paths_kernel, 3, sizeof(points_buffer), &points_buffer);
b09c5d
	cl.err |= clSetKernelArg(contour_draw_kernel, 3, sizeof(paths_buffer), &paths_buffer);
b09c5d
	assert(!cl.err);
b09c5d
b09c5d
	wait();
b09c5d
}
b09c5d
b09c5d
void ClRender2::draw() {
b09c5d
	//Measure t("ClRender::contour");
b09c5d
b09c5d
	cl_event prepare_event;
b09c5d
	cl_event paths_event;
b09c5d
b09c5d
	size_t count = surface->height;
b09c5d
	cl.err |= clEnqueueNDRangeKernel(
b09c5d
		cl.queue,
b09c5d
		contour_reset_kernel,
b09c5d
		1,
b09c5d
		NULL,
b09c5d
		&count,
b09c5d
		NULL,
b09c5d
		prev_event ? 1 : 0,
b09c5d
		prev_event ? &prev_event : NULL,
b09c5d
		&prepare_event );
b09c5d
	assert(!cl.err);
b09c5d
b09c5d
	count = points_count - 1;
b09c5d
	cl.err |= clEnqueueNDRangeKernel(
b09c5d
		cl.queue,
b09c5d
		contour_paths_kernel,
b09c5d
		1,
b09c5d
		NULL,
b09c5d
		&count,
b09c5d
		NULL,
b09c5d
		1,
b09c5d
		&prepare_event,
b09c5d
		&paths_event );
b09c5d
	assert(!cl.err);
b09c5d
b09c5d
	count = surface->height;
b09c5d
	cl.err |= clEnqueueNDRangeKernel(
b09c5d
		cl.queue,
b09c5d
		contour_draw_kernel,
b09c5d
		1,
b09c5d
		NULL,
b09c5d
		&count,
b09c5d
		NULL,
b09c5d
		1,
b09c5d
		&paths_event,
b09c5d
		&prev_event );
b09c5d
	assert(!cl.err);
b09c5d
}
b09c5d
b09c5d
void ClRender2::wait() {
b09c5d
	cl.err |= clFinish(cl.queue);
b09c5d
	assert(!cl.err);
b09c5d
	prev_event = NULL;
b09c5d
}
b09c5d
b09c5d
105dfe
// ------------------------------------------------
105dfe
105dfe
105dfe
ClRender3::ClRender3(ClContext &cl):
105dfe
	cl(cl),
105dfe
	contour_program(),
105dfe
	contour_path_kernel(),
105dfe
	contour_fill_kernel(),
105dfe
	surface(),
105dfe
	points_buffer(),
105dfe
	mark_buffer(),
105dfe
	surface_image(),
105dfe
	prev_event()
105dfe
{
105dfe
	contour_program = cl.load_program("contour-base.cl");
105dfe
	assert(contour_program);
105dfe
105dfe
	contour_path_kernel = clCreateKernel(contour_program, "path", &cl.err);
105dfe
	assert(!cl.err);
105dfe
	assert(contour_path_kernel);
105dfe
105dfe
	contour_fill_kernel = clCreateKernel(contour_program, "fill", &cl.err);
105dfe
	assert(!cl.err);
105dfe
	assert(contour_fill_kernel);
105dfe
}
105dfe
105dfe
ClRender3::~ClRender3() {
105dfe
	send_points(NULL, 0);
105dfe
	send_surface(NULL);
105dfe
a7622f
	cl.err |= clReleaseKernel(contour_path_kernel);
a7622f
	cl.err |= clReleaseKernel(contour_fill_kernel);
a7622f
	cl.err |= clReleaseProgram(contour_program);
a7622f
	assert(!cl.err);
105dfe
}
105dfe
105dfe
void ClRender3::send_surface(Surface *surface) {
105dfe
	if (this->surface) {
105dfe
		wait();
105dfe
		cl.err |= clReleaseMemObject(surface_image);
105dfe
		assert(!cl.err);
105dfe
		surface_image = NULL;
105dfe
	}
105dfe
105dfe
	this->surface = surface;
105dfe
105dfe
	if (this->surface) {
105dfe
		//Measure t("ClRender::send_surface");
105dfe
a7622f
		vec2i zero_mark;
105dfe
105dfe
		surface_image = clCreateBuffer(
105dfe
			cl.context, CL_MEM_READ_WRITE,
105dfe
			surface->count()*sizeof(Color), NULL,
105dfe
			&cl.err );
105dfe
		assert(!cl.err);
105dfe
		assert(surface_image);
105dfe
105dfe
		mark_buffer = clCreateBuffer(
105dfe
			cl.context, CL_MEM_READ_WRITE,
105dfe
			surface->count()*sizeof(zero_mark), NULL,
105dfe
			&cl.err );
105dfe
		assert(!cl.err);
105dfe
		assert(mark_buffer);
105dfe
105dfe
		cl.err |= clEnqueueWriteBuffer(
105dfe
			cl.queue, surface_image, false,
105dfe
			0, surface->count()*sizeof(Color), surface->data,
105dfe
			0, NULL, NULL );
105dfe
		assert(!cl.err);
105dfe
a7622f
		cl.err |= clEnqueueFillBuffer(
a7622f
			cl.queue, mark_buffer,
a7622f
			&zero_mark, sizeof(zero_mark),
a7622f
			0, surface->count()*sizeof(zero_mark),
105dfe
			0, NULL, NULL );
105dfe
		assert(!cl.err);
105dfe
105dfe
		cl.err |= clSetKernelArg(contour_path_kernel, 0, sizeof(surface->width), &surface->width);
105dfe
		cl.err |= clSetKernelArg(contour_path_kernel, 1, sizeof(surface->height), &surface->height);
105dfe
		cl.err |= clSetKernelArg(contour_path_kernel, 2, sizeof(mark_buffer), &mark_buffer);
105dfe
		assert(!cl.err);
105dfe
a7622f
		cl.err |= clSetKernelArg(contour_fill_kernel, 0, sizeof(surface->width), &surface->width);
20cefb
		cl.err |= clSetKernelArg(contour_fill_kernel, 1, sizeof(mark_buffer), &mark_buffer);
20cefb
		cl.err |= clSetKernelArg(contour_fill_kernel, 2, sizeof(surface_image), &surface_image);
105dfe
		assert(!cl.err);
105dfe
105dfe
		wait();
105dfe
	}
105dfe
}
105dfe
105dfe
Surface* ClRender3::receive_surface() {
105dfe
	if (surface) {
105dfe
		//Measure t("ClRender::receive_surface");
105dfe
105dfe
		cl.err |= clEnqueueReadBuffer(
105dfe
			cl.queue, surface_image, CL_FALSE,
105dfe
			0, surface->count()*sizeof(Color), surface->data,
105dfe
			prev_event ? 1 : 0,
105dfe
			prev_event ? &prev_event : NULL,
105dfe
			NULL );
105dfe
		assert(!cl.err);
105dfe
105dfe
		wait();
105dfe
	}
105dfe
	return surface;
105dfe
}
105dfe
105dfe
void ClRender3::send_points(const vec2f *points, int count) {
105dfe
	if (points_buffer) {
105dfe
		wait();
105dfe
		cl.err |= clReleaseMemObject(points_buffer);
105dfe
		assert(!cl.err);
105dfe
		points_buffer = NULL;
105dfe
	}
105dfe
105dfe
	if (points && count > 0) {
105dfe
		points_buffer = clCreateBuffer(
105dfe
			cl.context, CL_MEM_READ_ONLY,
105dfe
			count*sizeof(vec2f), NULL,
105dfe
			&cl.err );
105dfe
		assert(!cl.err);
105dfe
		assert(points_buffer);
105dfe
105dfe
		cl.err |= clEnqueueWriteBuffer(
105dfe
			cl.queue, points_buffer, false,
105dfe
			0, count*sizeof(vec2f), points,
105dfe
			0, NULL, NULL );
105dfe
		assert(!cl.err);
105dfe
105dfe
		cl.err |= clSetKernelArg(contour_path_kernel, 3, sizeof(points_buffer), &points_buffer);
105dfe
		assert(!cl.err);
105dfe
105dfe
		wait();
105dfe
	}
105dfe
}
105dfe
105dfe
void ClRender3::draw(const Path &path) {
105dfe
	//Measure t("ClRender::contour");
105dfe
105dfe
	assert(surface);
105dfe
	assert(points_buffer);
105dfe
f14ea7
	ContextRect bounds;
f14ea7
	bounds.minx = max(1, path.bounds.minx);
f14ea7
	bounds.maxx = min(surface->width, path.bounds.maxx);
f14ea7
	bounds.miny = max(0, path.bounds.miny);
f14ea7
	bounds.maxy = min(surface->height, path.bounds.maxy);
f14ea7
	if ( bounds.minx >= bounds.maxx
f14ea7
	  || bounds.miny >= bounds.maxy
f14ea7
	  || path.begin >= path.end ) return;
105dfe
20cefb
	vec2i boundsx(bounds.minx, bounds.maxx);
105dfe
77d271
	cl.err |= clSetKernelArg(contour_path_kernel, 4, sizeof(path.end), &path.end);
77d271
	cl.err |= clSetKernelArg(contour_path_kernel, 5, sizeof(bounds.minx), &bounds.minx);
105dfe
	assert(!cl.err);
105dfe
20cefb
	cl.err |= clSetKernelArg(contour_fill_kernel, 3, sizeof(path.color), &path.color);
77d271
	cl.err |= clSetKernelArg(contour_fill_kernel, 4, sizeof(bounds), &bounds);
20cefb
	assert(!cl.err);
105dfe
77d271
	size_t group_size, offset, count;
77d271
77d271
	offset = path.begin;
77d271
	count = path.end - path.begin - 1;
8cf99a
	group_size = 128;
77d271
77d271
	count = ((count - 1)/group_size + 1)*group_size;
105dfe
	cl.err |= clEnqueueNDRangeKernel(
20cefb
		cl.queue, contour_path_kernel,
77d271
		1, &offset, &count, &group_size,
20cefb
		0, NULL, NULL );
105dfe
	assert(!cl.err);
105dfe
a7622f
	offset = bounds.minx;
a7622f
	count = bounds.maxx - bounds.minx;
8cf99a
	group_size = 16;
77d271
77d271
	count = ((count - 1)/group_size + 1)*group_size;
105dfe
	cl.err |= clEnqueueNDRangeKernel(
20cefb
		cl.queue, contour_fill_kernel,
77d271
		1, &offset, &count, &group_size,
20cefb
		0, NULL, NULL );
105dfe
	assert(!cl.err);
105dfe
}
105dfe
105dfe
void ClRender3::wait() {
105dfe
	cl.err |= clFinish(cl.queue);
105dfe
	assert(!cl.err);
20cefb
	if (prev_event) {
20cefb
		cl.err |= clReleaseEvent(prev_event);
20cefb
		assert(!cl.err);
20cefb
		prev_event = NULL;
20cefb
	}
105dfe
}
105dfe