mirror of
https://github.com/aseprite/aseprite.git
synced 2024-12-26 18:21:44 +00:00
376 lines
11 KiB
C
376 lines
11 KiB
C
/* Libart_LGPL - library of basic graphic primitives
|
|
* Copyright (C) 1998-2000 Raph Levien
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library 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
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library; if not, write to the
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
/* LGPL Copyright 1998 Raph Levien <raph@acm.org> */
|
|
|
|
#include <math.h>
|
|
|
|
#include "art_misc.h"
|
|
#include "art_vpath.h"
|
|
#include "art_uta.h"
|
|
#include "art_uta_vpath.h"
|
|
|
|
#ifndef MAX
|
|
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
|
|
#endif /* MAX */
|
|
|
|
#ifndef MIN
|
|
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
|
|
#endif /* MIN */
|
|
|
|
/**
|
|
* art_uta_add_line: Add a line to the uta.
|
|
* @uta: The uta to modify.
|
|
* @x0: X coordinate of line start point.
|
|
* @y0: Y coordinate of line start point.
|
|
* @x1: X coordinate of line end point.
|
|
* @y1: Y coordinate of line end point.
|
|
* @rbuf: Buffer containing first difference of winding number.
|
|
* @rbuf_rowstride: Rowstride of @rbuf.
|
|
*
|
|
* Add the line (@x0, @y0) - (@x1, @y1) to @uta, and also update the
|
|
* winding number buffer used for rendering the interior. @rbuf
|
|
* contains the first partial difference (in the X direction) of the
|
|
* winding number, measured in grid cells. Thus, each time that a line
|
|
* crosses a horizontal uta grid line, an entry of @rbuf is
|
|
* incremented if @y1 > @y0, decremented otherwise.
|
|
*
|
|
* Note that edge handling is fairly delicate. Please rtfs for
|
|
* details.
|
|
**/
|
|
void
|
|
art_uta_add_line (ArtUta *uta, double x0, double y0, double x1, double y1,
|
|
int *rbuf, int rbuf_rowstride)
|
|
{
|
|
int xmin, ymin;
|
|
double xmax, ymax;
|
|
int xmaxf, ymaxf;
|
|
int xmaxc, ymaxc;
|
|
int xt0, yt0;
|
|
int xt1, yt1;
|
|
int xf0, yf0;
|
|
int xf1, yf1;
|
|
int ix, ix1;
|
|
ArtUtaBbox bb;
|
|
|
|
xmin = floor (MIN(x0, x1));
|
|
xmax = MAX(x0, x1);
|
|
xmaxf = floor (xmax);
|
|
xmaxc = ceil (xmax);
|
|
ymin = floor (MIN(y0, y1));
|
|
ymax = MAX(y0, y1);
|
|
ymaxf = floor (ymax);
|
|
ymaxc = ceil (ymax);
|
|
xt0 = (xmin >> ART_UTILE_SHIFT) - uta->x0;
|
|
yt0 = (ymin >> ART_UTILE_SHIFT) - uta->y0;
|
|
xt1 = (xmaxf >> ART_UTILE_SHIFT) - uta->x0;
|
|
yt1 = (ymaxf >> ART_UTILE_SHIFT) - uta->y0;
|
|
if (xt0 == xt1 && yt0 == yt1)
|
|
{
|
|
/* entirely inside a microtile, this is easy! */
|
|
xf0 = xmin & (ART_UTILE_SIZE - 1);
|
|
yf0 = ymin & (ART_UTILE_SIZE - 1);
|
|
xf1 = (xmaxf & (ART_UTILE_SIZE - 1)) + xmaxc - xmaxf;
|
|
yf1 = (ymaxf & (ART_UTILE_SIZE - 1)) + ymaxc - ymaxf;
|
|
|
|
ix = yt0 * uta->width + xt0;
|
|
bb = uta->utiles[ix];
|
|
if (bb == 0)
|
|
bb = ART_UTA_BBOX_CONS(xf0, yf0, xf1, yf1);
|
|
else
|
|
bb = ART_UTA_BBOX_CONS(MIN(ART_UTA_BBOX_X0(bb), xf0),
|
|
MIN(ART_UTA_BBOX_Y0(bb), yf0),
|
|
MAX(ART_UTA_BBOX_X1(bb), xf1),
|
|
MAX(ART_UTA_BBOX_Y1(bb), yf1));
|
|
uta->utiles[ix] = bb;
|
|
}
|
|
else
|
|
{
|
|
double dx, dy;
|
|
int sx, sy;
|
|
|
|
dx = x1 - x0;
|
|
dy = y1 - y0;
|
|
sx = dx > 0 ? 1 : dx < 0 ? -1 : 0;
|
|
sy = dy > 0 ? 1 : dy < 0 ? -1 : 0;
|
|
if (ymin == ymaxf)
|
|
{
|
|
/* special case horizontal (dx/dy slope would be infinite) */
|
|
xf0 = xmin & (ART_UTILE_SIZE - 1);
|
|
yf0 = ymin & (ART_UTILE_SIZE - 1);
|
|
xf1 = (xmaxf & (ART_UTILE_SIZE - 1)) + xmaxc - xmaxf;
|
|
yf1 = (ymaxf & (ART_UTILE_SIZE - 1)) + ymaxc - ymaxf;
|
|
|
|
ix = yt0 * uta->width + xt0;
|
|
ix1 = yt0 * uta->width + xt1;
|
|
while (ix != ix1)
|
|
{
|
|
bb = uta->utiles[ix];
|
|
if (bb == 0)
|
|
bb = ART_UTA_BBOX_CONS(xf0, yf0, ART_UTILE_SIZE, yf1);
|
|
else
|
|
bb = ART_UTA_BBOX_CONS(MIN(ART_UTA_BBOX_X0(bb), xf0),
|
|
MIN(ART_UTA_BBOX_Y0(bb), yf0),
|
|
ART_UTILE_SIZE,
|
|
MAX(ART_UTA_BBOX_Y1(bb), yf1));
|
|
uta->utiles[ix] = bb;
|
|
xf0 = 0;
|
|
ix++;
|
|
}
|
|
bb = uta->utiles[ix];
|
|
if (bb == 0)
|
|
bb = ART_UTA_BBOX_CONS(0, yf0, xf1, yf1);
|
|
else
|
|
bb = ART_UTA_BBOX_CONS(0,
|
|
MIN(ART_UTA_BBOX_Y0(bb), yf0),
|
|
MAX(ART_UTA_BBOX_X1(bb), xf1),
|
|
MAX(ART_UTA_BBOX_Y1(bb), yf1));
|
|
uta->utiles[ix] = bb;
|
|
}
|
|
else
|
|
{
|
|
/* Do a Bresenham-style traversal of the line */
|
|
double dx_dy;
|
|
double x, y;
|
|
double xn, yn;
|
|
|
|
/* normalize coordinates to uta origin */
|
|
x0 -= uta->x0 << ART_UTILE_SHIFT;
|
|
y0 -= uta->y0 << ART_UTILE_SHIFT;
|
|
x1 -= uta->x0 << ART_UTILE_SHIFT;
|
|
y1 -= uta->y0 << ART_UTILE_SHIFT;
|
|
if (dy < 0)
|
|
{
|
|
double tmp;
|
|
|
|
tmp = x0;
|
|
x0 = x1;
|
|
x1 = tmp;
|
|
|
|
tmp = y0;
|
|
y0 = y1;
|
|
y1 = tmp;
|
|
|
|
dx = -dx;
|
|
sx = -sx;
|
|
dy = -dy;
|
|
/* we leave sy alone, because it would always be 1,
|
|
and we need it for the rbuf stuff. */
|
|
}
|
|
xt0 = ((int)floor (x0) >> ART_UTILE_SHIFT);
|
|
xt1 = ((int)floor (x1) >> ART_UTILE_SHIFT);
|
|
/* now [xy]0 is above [xy]1 */
|
|
|
|
ix = yt0 * uta->width + xt0;
|
|
ix1 = yt1 * uta->width + xt1;
|
|
#ifdef VERBOSE
|
|
printf ("%% ix = %d,%d; ix1 = %d,%d\n", xt0, yt0, xt1, yt1);
|
|
#endif
|
|
|
|
dx_dy = dx / dy;
|
|
x = x0;
|
|
y = y0;
|
|
while (ix != ix1)
|
|
{
|
|
int dix;
|
|
|
|
/* figure out whether next crossing is horizontal or vertical */
|
|
#ifdef VERBOSE
|
|
printf ("%% %d,%d\n", xt0, yt0);
|
|
#endif
|
|
yn = (yt0 + 1) << ART_UTILE_SHIFT;
|
|
xn = x0 + dx_dy * (yn - y0);
|
|
if (xt0 != (int)floor (xn) >> ART_UTILE_SHIFT)
|
|
{
|
|
/* horizontal crossing */
|
|
xt0 += sx;
|
|
dix = sx;
|
|
if (dx > 0)
|
|
{
|
|
xn = xt0 << ART_UTILE_SHIFT;
|
|
yn = y0 + (xn - x0) / dx_dy;
|
|
|
|
xf0 = (int)floor (x) & (ART_UTILE_SIZE - 1);
|
|
xf1 = ART_UTILE_SIZE;
|
|
}
|
|
else
|
|
{
|
|
xn = (xt0 + 1) << ART_UTILE_SHIFT;
|
|
yn = y0 + (xn - x0) / dx_dy;
|
|
|
|
xf0 = 0;
|
|
xmaxc = (int)ceil (x);
|
|
xf1 = xmaxc - ((xt0 + 1) << ART_UTILE_SHIFT);
|
|
}
|
|
ymaxf = (int)floor (yn);
|
|
ymaxc = (int)ceil (yn);
|
|
yf1 = (ymaxf & (ART_UTILE_SIZE - 1)) + ymaxc - ymaxf;
|
|
}
|
|
else
|
|
{
|
|
/* vertical crossing */
|
|
dix = uta->width;
|
|
xf0 = (int)floor (MIN(x, xn)) & (ART_UTILE_SIZE - 1);
|
|
xmax = MAX(x, xn);
|
|
xmaxc = (int)ceil (xmax);
|
|
xf1 = xmaxc - (xt0 << ART_UTILE_SHIFT);
|
|
yf1 = ART_UTILE_SIZE;
|
|
|
|
if (rbuf != NULL)
|
|
rbuf[yt0 * rbuf_rowstride + xt0] += sy;
|
|
|
|
yt0++;
|
|
}
|
|
yf0 = (int)floor (y) & (ART_UTILE_SIZE - 1);
|
|
bb = uta->utiles[ix];
|
|
if (bb == 0)
|
|
bb = ART_UTA_BBOX_CONS(xf0, yf0, xf1, yf1);
|
|
else
|
|
bb = ART_UTA_BBOX_CONS(MIN(ART_UTA_BBOX_X0(bb), xf0),
|
|
MIN(ART_UTA_BBOX_Y0(bb), yf0),
|
|
MAX(ART_UTA_BBOX_X1(bb), xf1),
|
|
MAX(ART_UTA_BBOX_Y1(bb), yf1));
|
|
uta->utiles[ix] = bb;
|
|
|
|
x = xn;
|
|
y = yn;
|
|
ix += dix;
|
|
}
|
|
xmax = MAX(x, x1);
|
|
xmaxc = ceil (xmax);
|
|
ymaxc = ceil (y1);
|
|
xf0 = (int)floor (MIN(x1, x)) & (ART_UTILE_SIZE - 1);
|
|
yf0 = (int)floor (y) & (ART_UTILE_SIZE - 1);
|
|
xf1 = xmaxc - (xt0 << ART_UTILE_SHIFT);
|
|
yf1 = ymaxc - (yt0 << ART_UTILE_SHIFT);
|
|
bb = uta->utiles[ix];
|
|
if (bb == 0)
|
|
bb = ART_UTA_BBOX_CONS(xf0, yf0, xf1, yf1);
|
|
else
|
|
bb = ART_UTA_BBOX_CONS(MIN(ART_UTA_BBOX_X0(bb), xf0),
|
|
MIN(ART_UTA_BBOX_Y0(bb), yf0),
|
|
MAX(ART_UTA_BBOX_X1(bb), xf1),
|
|
MAX(ART_UTA_BBOX_Y1(bb), yf1));
|
|
uta->utiles[ix] = bb;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* art_uta_from_vpath: Generate uta covering a vpath.
|
|
* @vec: The source vpath.
|
|
*
|
|
* Generates a uta covering @vec. The resulting uta is of course
|
|
* approximate, ie it may cover more pixels than covered by @vec.
|
|
*
|
|
* Return value: the new uta.
|
|
**/
|
|
ArtUta *
|
|
art_uta_from_vpath (const ArtVpath *vec)
|
|
{
|
|
ArtUta *uta;
|
|
ArtIRect bbox;
|
|
int *rbuf;
|
|
int i;
|
|
double x, y;
|
|
int sum;
|
|
int xt, yt;
|
|
ArtUtaBbox *utiles;
|
|
ArtUtaBbox bb;
|
|
int width;
|
|
int height;
|
|
int ix;
|
|
|
|
art_vpath_bbox_irect (vec, &bbox);
|
|
|
|
uta = art_uta_new_coords (bbox.x0, bbox.y0, bbox.x1, bbox.y1);
|
|
|
|
width = uta->width;
|
|
height = uta->height;
|
|
utiles = uta->utiles;
|
|
|
|
rbuf = art_new (int, width * height);
|
|
for (i = 0; i < width * height; i++)
|
|
rbuf[i] = 0;
|
|
|
|
x = 0;
|
|
y = 0;
|
|
for (i = 0; vec[i].code != ART_END; i++)
|
|
{
|
|
switch (vec[i].code)
|
|
{
|
|
case ART_MOVETO:
|
|
x = vec[i].x;
|
|
y = vec[i].y;
|
|
break;
|
|
case ART_LINETO:
|
|
art_uta_add_line (uta, vec[i].x, vec[i].y, x, y, rbuf, width);
|
|
x = vec[i].x;
|
|
y = vec[i].y;
|
|
break;
|
|
default:
|
|
/* this shouldn't happen */
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* now add in the filling from rbuf */
|
|
ix = 0;
|
|
for (yt = 0; yt < height; yt++)
|
|
{
|
|
sum = 0;
|
|
for (xt = 0; xt < width; xt++)
|
|
{
|
|
sum += rbuf[ix];
|
|
/* Nonzero winding rule - others are possible, but hardly
|
|
worth it. */
|
|
if (sum != 0)
|
|
{
|
|
bb = utiles[ix];
|
|
bb &= 0xffff0000;
|
|
bb |= (ART_UTILE_SIZE << 8) | ART_UTILE_SIZE;
|
|
utiles[ix] = bb;
|
|
if (xt != width - 1)
|
|
{
|
|
bb = utiles[ix + 1];
|
|
bb &= 0xffff00;
|
|
bb |= ART_UTILE_SIZE;
|
|
utiles[ix + 1] = bb;
|
|
}
|
|
if (yt != height - 1)
|
|
{
|
|
bb = utiles[ix + width];
|
|
bb &= 0xff0000ff;
|
|
bb |= ART_UTILE_SIZE << 8;
|
|
utiles[ix + width] = bb;
|
|
if (xt != width - 1)
|
|
{
|
|
utiles[ix + width + 1] &= 0xffff;
|
|
}
|
|
}
|
|
}
|
|
ix++;
|
|
}
|
|
}
|
|
|
|
art_free (rbuf);
|
|
|
|
return uta;
|
|
}
|