548 lines
12 KiB
Java
548 lines
12 KiB
Java
/*
|
|
* Copyright 2013 Hannes Janetzek
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify it under the
|
|
* terms of the GNU Lesser General 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 Lesser General License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General License along with
|
|
* this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
package org.oscim.renderer.layer;
|
|
|
|
import java.nio.ShortBuffer;
|
|
|
|
import org.oscim.core.Tile;
|
|
import org.oscim.renderer.GLRenderer;
|
|
import org.oscim.theme.renderinstruction.Line;
|
|
import org.oscim.utils.FastMath;
|
|
import org.oscim.view.MapView;
|
|
|
|
import android.graphics.Paint.Cap;
|
|
|
|
/**
|
|
* @author Hannes Janetzek
|
|
*/
|
|
public final class LineLayer extends Layer {
|
|
private static final float COORD_SCALE = GLRenderer.COORD_SCALE;
|
|
// scale factor mapping extrusion vector to short values
|
|
public static final float DIR_SCALE = 2048;
|
|
// mask for packing last two bits of extrusion vector with texture
|
|
// coordinates
|
|
private static final int DIR_MASK = 0xFFFFFFFC;
|
|
|
|
// lines referenced by this outline layer
|
|
public LineLayer outlines;
|
|
public Line line;
|
|
public float width;
|
|
|
|
public boolean roundCap;
|
|
|
|
LineLayer(int layer) {
|
|
this.level = layer;
|
|
this.type = Layer.LINE;
|
|
}
|
|
|
|
public void addOutline(LineLayer link) {
|
|
for (LineLayer l = outlines; l != null; l = l.outlines)
|
|
if (link == l)
|
|
return;
|
|
|
|
link.outlines = outlines;
|
|
outlines = link;
|
|
}
|
|
|
|
/**
|
|
* line extrusion is based on code from GLMap
|
|
* (https://github.com/olofsj/GLMap/)
|
|
*
|
|
* @param points
|
|
* array of points as x,y pairs.
|
|
* @param index
|
|
* array of indices holding the length of the individual
|
|
* line coordinates (i.e. points * 2).
|
|
* when index is null one a line with points.length
|
|
* is assumed.
|
|
* @param closed
|
|
* whether to connect start- and end-point.
|
|
*/
|
|
public void addLine(float[] points, short[] index, boolean closed) {
|
|
float x, y, nextX, nextY;
|
|
float a, ux, uy, vx, vy, wx, wy;
|
|
|
|
int tmax = Tile.SIZE + 4;
|
|
int tmin = -4;
|
|
|
|
boolean rounded = false;
|
|
boolean squared = false;
|
|
|
|
if (line.cap == Cap.ROUND)
|
|
rounded = true;
|
|
else if (line.cap == Cap.SQUARE)
|
|
squared = true;
|
|
|
|
if (pool == null)
|
|
curItem = pool = VertexPool.get();
|
|
|
|
VertexPoolItem si = curItem;
|
|
short v[] = si.vertices;
|
|
int opos = si.used;
|
|
|
|
// FIXME: remove this when switching to oscimap MapDatabase
|
|
if (!MapView.enableClosePolygons)
|
|
closed = false;
|
|
|
|
// Note: just a hack to save some vertices, when there are more than 200 lines
|
|
// per type
|
|
if (rounded) {
|
|
int cnt = 0;
|
|
for (int i = 0, n = index.length; i < n; i++, cnt++) {
|
|
if (index[i] < 0)
|
|
break;
|
|
if (cnt > 400) {
|
|
rounded = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
roundCap = rounded;
|
|
|
|
int n;
|
|
int length = 0;
|
|
|
|
if (index == null){
|
|
n = 1;
|
|
length = points.length;
|
|
} else{
|
|
n = index.length;
|
|
}
|
|
|
|
for (int i = 0, pos = 0; i < n; i++) {
|
|
if (index != null)
|
|
length = index[i];
|
|
|
|
// check end-marker in indices
|
|
if (length < 0)
|
|
break;
|
|
|
|
// need at least two points
|
|
if (length < 4) {
|
|
pos += length;
|
|
continue;
|
|
}
|
|
|
|
// amount of vertices used
|
|
// + 2 for drawing triangle-strip
|
|
// + 4 for round caps
|
|
// + 2 for closing polygons
|
|
verticesCnt += length + (rounded ? 6 : 2) + (closed ? 2 : 0);
|
|
|
|
int ipos = pos;
|
|
|
|
x = points[ipos++];
|
|
y = points[ipos++];
|
|
|
|
nextX = points[ipos++];
|
|
nextY = points[ipos++];
|
|
|
|
// Calculate triangle corners for the given width
|
|
vx = nextX - x;
|
|
vy = nextY - y;
|
|
|
|
// Unit vector to next node
|
|
a = (float) Math.sqrt(vx * vx + vy * vy);
|
|
vx /= a;
|
|
vy /= a;
|
|
|
|
// perpendicular on the first segment
|
|
ux = -vy;
|
|
uy = vx;
|
|
|
|
int ddx, ddy;
|
|
|
|
// vertex point coordinate
|
|
short ox = (short) (x * COORD_SCALE);
|
|
short oy = (short) (y * COORD_SCALE);
|
|
|
|
// vertex extrusion vector, last two bit
|
|
// encode texture coord.
|
|
short dx, dy;
|
|
|
|
// when the endpoint is outside the tile region omit round caps.
|
|
boolean outside = (x < tmin || x > tmax || y < tmin || y > tmax);
|
|
|
|
if (opos == VertexPoolItem.SIZE) {
|
|
si = si.next = VertexPool.get();
|
|
v = si.vertices;
|
|
opos = 0;
|
|
}
|
|
|
|
if (rounded && !outside) {
|
|
// add first vertex twice
|
|
ddx = (int) ((ux - vx) * DIR_SCALE);
|
|
ddy = (int) ((uy - vy) * DIR_SCALE);
|
|
dx = (short) (0 | ddx & DIR_MASK);
|
|
dy = (short) (2 | ddy & DIR_MASK);
|
|
|
|
v[opos++] = ox;
|
|
v[opos++] = oy;
|
|
v[opos++] = dx;
|
|
v[opos++] = dy;
|
|
|
|
if (opos == VertexPoolItem.SIZE) {
|
|
si = si.next = VertexPool.get();
|
|
v = si.vertices;
|
|
opos = 0;
|
|
}
|
|
|
|
v[opos++] = ox;
|
|
v[opos++] = oy;
|
|
v[opos++] = dx;
|
|
v[opos++] = dy;
|
|
|
|
if (opos == VertexPoolItem.SIZE) {
|
|
si = si.next = VertexPool.get();
|
|
v = si.vertices;
|
|
opos = 0;
|
|
}
|
|
|
|
ddx = (int) (-(ux + vx) * DIR_SCALE);
|
|
ddy = (int) (-(uy + vy) * DIR_SCALE);
|
|
|
|
v[opos++] = ox;
|
|
v[opos++] = oy;
|
|
v[opos++] = (short) (2 | ddx & DIR_MASK);
|
|
v[opos++] = (short) (2 | ddy & DIR_MASK);
|
|
|
|
if (opos == VertexPoolItem.SIZE) {
|
|
si = si.next = VertexPool.get();
|
|
v = si.vertices;
|
|
opos = 0;
|
|
}
|
|
|
|
// Start of line
|
|
ddx = (int) (ux * DIR_SCALE);
|
|
ddy = (int) (uy * DIR_SCALE);
|
|
|
|
v[opos++] = ox;
|
|
v[opos++] = oy;
|
|
v[opos++] = (short) (0 | ddx & DIR_MASK);
|
|
v[opos++] = (short) (1 | ddy & DIR_MASK);
|
|
|
|
if (opos == VertexPoolItem.SIZE) {
|
|
si = si.next = VertexPool.get();
|
|
v = si.vertices;
|
|
opos = 0;
|
|
}
|
|
|
|
v[opos++] = ox;
|
|
v[opos++] = oy;
|
|
v[opos++] = (short) (2 | -ddx & DIR_MASK);
|
|
v[opos++] = (short) (1 | -ddy & DIR_MASK);
|
|
|
|
} else {
|
|
// outside means line is probably clipped
|
|
// TODO should align ending with tile boundary
|
|
// for now, just extend the line a little
|
|
float tx = vx;
|
|
float ty = vy;
|
|
|
|
if (squared) {
|
|
tx = 0;
|
|
ty = 0;
|
|
} else if (!outside) {
|
|
tx *= 0.5;
|
|
ty *= 0.5;
|
|
}
|
|
|
|
if (rounded)
|
|
verticesCnt -= 2;
|
|
|
|
// add first vertex twice
|
|
ddx = (int) ((ux - tx) * DIR_SCALE);
|
|
ddy = (int) ((uy - ty) * DIR_SCALE);
|
|
dx = (short) (0 | ddx & DIR_MASK);
|
|
dy = (short) (1 | ddy & DIR_MASK);
|
|
|
|
v[opos++] = ox;
|
|
v[opos++] = oy;
|
|
v[opos++] = dx;
|
|
v[opos++] = dy;
|
|
|
|
if (opos == VertexPoolItem.SIZE) {
|
|
si = si.next = VertexPool.get();
|
|
v = si.vertices;
|
|
opos = 0;
|
|
}
|
|
|
|
v[opos++] = ox;
|
|
v[opos++] = oy;
|
|
v[opos++] = dx;
|
|
v[opos++] = dy;
|
|
|
|
if (opos == VertexPoolItem.SIZE) {
|
|
si = si.next = VertexPool.get();
|
|
v = si.vertices;
|
|
opos = 0;
|
|
}
|
|
|
|
ddx = (int) (-(ux + tx) * DIR_SCALE);
|
|
ddy = (int) (-(uy + ty) * DIR_SCALE);
|
|
|
|
v[opos++] = ox;
|
|
v[opos++] = oy;
|
|
v[opos++] = (short) (2 | ddx & DIR_MASK);
|
|
v[opos++] = (short) (1 | ddy & DIR_MASK);
|
|
|
|
}
|
|
|
|
x = nextX;
|
|
y = nextY;
|
|
boolean flip = false;
|
|
// Unit vector pointing back to previous node
|
|
vx *= -1;
|
|
vy *= -1;
|
|
|
|
int end = pos + length;
|
|
|
|
for (;;) {
|
|
if (ipos < end) {
|
|
nextX = points[ipos++];
|
|
nextY = points[ipos++];
|
|
} else if (closed && ipos < end + 2) {
|
|
// add startpoint == endpoint
|
|
nextX = points[pos];
|
|
nextY = points[pos + 1];
|
|
ipos += 2;
|
|
} else
|
|
break;
|
|
|
|
// Unit vector pointing forward to next node
|
|
wx = nextX - x;
|
|
wy = nextY - y;
|
|
a = (float) Math.sqrt(wx * wx + wy * wy);
|
|
wx /= a;
|
|
wy /= a;
|
|
|
|
// Sum of these two vectors points
|
|
ux = vx + wx;
|
|
uy = vy + wy;
|
|
|
|
// cross-product
|
|
a = wx * uy - wy * ux;
|
|
|
|
if (FastMath.abs(a) < 0.01f) {
|
|
// Almost straight
|
|
ux = -wy;
|
|
uy = wx;
|
|
} else {
|
|
ux /= a;
|
|
uy /= a;
|
|
|
|
// avoid miter going to infinity.
|
|
// TODO add option for round joints
|
|
if (FastMath.absMaxCmp(ux, uy, 4f)) {
|
|
ux = vx - wx;
|
|
uy = vy - wy;
|
|
|
|
a = -wy * ux + wx * uy;
|
|
ux /= a;
|
|
uy /= a;
|
|
flip = !flip;
|
|
}
|
|
}
|
|
|
|
ox = (short) (x * COORD_SCALE);
|
|
oy = (short) (y * COORD_SCALE);
|
|
|
|
ddx = (int) (ux * DIR_SCALE);
|
|
ddy = (int) (uy * DIR_SCALE);
|
|
|
|
if (flip) {
|
|
ddx = -ddx;
|
|
ddy = -ddy;
|
|
}
|
|
if (opos == VertexPoolItem.SIZE) {
|
|
si = si.next = VertexPool.get();
|
|
v = si.vertices;
|
|
opos = 0;
|
|
}
|
|
|
|
v[opos++] = ox;
|
|
v[opos++] = oy;
|
|
v[opos++] = (short) (0 | ddx & DIR_MASK);
|
|
v[opos++] = (short) (1 | ddy & DIR_MASK);
|
|
|
|
if (opos == VertexPoolItem.SIZE) {
|
|
si = si.next = VertexPool.get();
|
|
v = si.vertices;
|
|
opos = 0;
|
|
}
|
|
|
|
v[opos++] = ox;
|
|
v[opos++] = oy;
|
|
v[opos++] = (short) (2 | -ddx & DIR_MASK);
|
|
v[opos++] = (short) (1 | -ddy & DIR_MASK);
|
|
|
|
x = nextX;
|
|
y = nextY;
|
|
|
|
// flip unit vector to point back
|
|
vx = -wx;
|
|
vy = -wy;
|
|
}
|
|
|
|
ux = vy;
|
|
uy = -vx;
|
|
|
|
outside = (x < tmin || x > tmax || y < tmin || y > tmax);
|
|
|
|
if (opos == VertexPoolItem.SIZE) {
|
|
si.next = VertexPool.get();
|
|
si = si.next;
|
|
opos = 0;
|
|
v = si.vertices;
|
|
}
|
|
|
|
ox = (short) (x * COORD_SCALE);
|
|
oy = (short) (y * COORD_SCALE);
|
|
|
|
if (rounded && !outside) {
|
|
ddx = (int) (ux * DIR_SCALE);
|
|
ddy = (int) (uy * DIR_SCALE);
|
|
|
|
if (flip) {
|
|
ddx = -ddx;
|
|
ddy = -ddy;
|
|
}
|
|
|
|
v[opos++] = ox;
|
|
v[opos++] = oy;
|
|
v[opos++] = (short) (0 | ddx & DIR_MASK);
|
|
v[opos++] = (short) (1 | ddy & DIR_MASK);
|
|
|
|
if (opos == VertexPoolItem.SIZE) {
|
|
si = si.next = VertexPool.get();
|
|
v = si.vertices;
|
|
opos = 0;
|
|
}
|
|
|
|
v[opos++] = ox;
|
|
v[opos++] = oy;
|
|
v[opos++] = (short) (2 | -ddx & DIR_MASK);
|
|
v[opos++] = (short) (1 | -ddy & DIR_MASK);
|
|
|
|
if (opos == VertexPoolItem.SIZE) {
|
|
si = si.next = VertexPool.get();
|
|
v = si.vertices;
|
|
opos = 0;
|
|
}
|
|
|
|
// For rounded line edges
|
|
ddx = (int) ((ux - vx) * DIR_SCALE);
|
|
ddy = (int) ((uy - vy) * DIR_SCALE);
|
|
|
|
dx = (short) (0 | (flip ? -ddx : ddx) & DIR_MASK);
|
|
dy = (short) (0 | (flip ? -ddy : ddy) & DIR_MASK);
|
|
|
|
v[opos++] = ox;
|
|
v[opos++] = oy;
|
|
v[opos++] = dx;
|
|
v[opos++] = dy;
|
|
|
|
if (opos == VertexPoolItem.SIZE) {
|
|
si = si.next = VertexPool.get();
|
|
v = si.vertices;
|
|
opos = 0;
|
|
}
|
|
|
|
// add last vertex twice
|
|
ddx = (int) (-(ux + vx) * DIR_SCALE);
|
|
ddy = (int) (-(uy + vy) * DIR_SCALE);
|
|
dx = (short) (2 | (flip ? -ddx : ddx) & DIR_MASK);
|
|
dy = (short) (0 | (flip ? -ddy : ddy) & DIR_MASK);
|
|
|
|
v[opos++] = ox;
|
|
v[opos++] = oy;
|
|
v[opos++] = dx;
|
|
v[opos++] = dy;
|
|
|
|
if (opos == VertexPoolItem.SIZE) {
|
|
si = si.next = VertexPool.get();
|
|
v = si.vertices;
|
|
opos = 0;
|
|
}
|
|
|
|
v[opos++] = ox;
|
|
v[opos++] = oy;
|
|
v[opos++] = dx;
|
|
v[opos++] = dy;
|
|
|
|
} else {
|
|
if (squared) {
|
|
vx = 0;
|
|
vy = 0;
|
|
} else if (!outside) {
|
|
vx *= 0.5;
|
|
vy *= 0.5;
|
|
}
|
|
|
|
if (rounded)
|
|
verticesCnt -= 2;
|
|
|
|
ddx = (int) ((ux - vx) * DIR_SCALE);
|
|
ddy = (int) ((uy - vy) * DIR_SCALE);
|
|
|
|
v[opos++] = ox;
|
|
v[opos++] = oy;
|
|
v[opos++] = (short) (0 | (flip ? -ddx : ddx) & DIR_MASK);
|
|
v[opos++] = (short) (1 | (flip ? -ddy : ddy) & DIR_MASK);
|
|
|
|
if (opos == VertexPoolItem.SIZE) {
|
|
si = si.next = VertexPool.get();
|
|
v = si.vertices;
|
|
opos = 0;
|
|
}
|
|
|
|
// add last vertex twice
|
|
ddx = (int) (-(ux + vx) * DIR_SCALE);
|
|
ddy = (int) (-(uy + vy) * DIR_SCALE);
|
|
dx = (short) (2 | (flip ? -ddx : ddx) & DIR_MASK);
|
|
dy = (short) (1 | (flip ? -ddy : ddy) & DIR_MASK);
|
|
|
|
v[opos++] = ox;
|
|
v[opos++] = oy;
|
|
v[opos++] = dx;
|
|
v[opos++] = dy;
|
|
|
|
if (opos == VertexPoolItem.SIZE) {
|
|
si = si.next = VertexPool.get();
|
|
v = si.vertices;
|
|
opos = 0;
|
|
}
|
|
|
|
v[opos++] = ox;
|
|
v[opos++] = oy;
|
|
v[opos++] = dx;
|
|
v[opos++] = dy;
|
|
}
|
|
pos += length;
|
|
}
|
|
|
|
si.used = opos;
|
|
curItem = si;
|
|
}
|
|
|
|
@Override
|
|
protected void clear() {
|
|
}
|
|
|
|
@Override
|
|
protected void compile(ShortBuffer sbuf) {
|
|
}
|
|
}
|