xiaoyan159/vtm
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

LineLayer refactor:

Browse Source 
- extract addLine()
- expand variable names
This commit is contained in:
Hannes Janetzek 2014-02-24 16:59:15 +01:00
parent 0ef16b6c5b
commit fdda6988ba
1 changed files with 402 additions and 455 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

565
vtm/src/org/oscim/renderer/elements/LineLayer.java
View File

@ -54,7 +54,7 @@ public final class LineLayer extends RenderElement {
* not quite right.. need to go back so that additional * not quite right.. need to go back so that additional
* bevel vertices are at least MIN_DIST apart * bevel vertices are at least MIN_DIST apart
*/ */
//private static final float JOIN_BEVEL = MIN_DIST private static final float BEVEL_MIN = MIN_DIST * 4;
/** /**
* mask for packing last two bits of extrusion vector with texture * mask for packing last two bits of extrusion vector with texture
@ -107,10 +107,10 @@ public final class LineLayer extends RenderElement {
addLine(points, null, numPoints, closed); addLine(points, null, numPoints, closed);
} }
private void addLine(float[] points, short[] index, int numPoints, boolean closed) { private static int tmax = Tile.SIZE + 4;
private static int tmin = -4;
int tmax = Tile.SIZE + 4; private void addLine(float[] points, short[] index, int numPoints, boolean closed) {
int tmin = -4;
boolean rounded = false; boolean rounded = false;
boolean squared = false; boolean squared = false;
@ -123,9 +123,7 @@ public final class LineLayer extends RenderElement {
if (vertexItems == null) if (vertexItems == null)
vertexItems = pool.get(); vertexItems = pool.get();
VertexItem si = Inlist.last(vertexItems); VertexItem vertexItem = Inlist.last(vertexItems);
short v[] = si.vertices;
int opos = si.used;
/* Note: just a hack to save some vertices, when there are /* Note: just a hack to save some vertices, when there are
* more than 200 lines per type. FIXME make optional! */ * more than 200 lines per type. FIXME make optional! */
@ -157,13 +155,6 @@ public final class LineLayer extends RenderElement {
} }
for (int i = 0, pos = 0; i < n; i++) { for (int i = 0, pos = 0; i < n; i++) {
float ux, uy;
float vx, vy;
float wx, wy;
float x, y;
float nextX, nextY;
double a;
if (index != null) if (index != null)
length = index[i]; length = index[i];
@ -171,11 +162,94 @@ public final class LineLayer extends RenderElement {
if (length < 0) if (length < 0)
break; break;
/* need at least two points */ int ipos = pos;
if (length < 4) {
pos += length; pos += length;
/* need at least two points */
if (length < 4)
continue; continue;
vertexItem = addLine(vertexItem, points, ipos, length, rounded, squared, closed);
} }
}
private void addVertex(short[] v, int pos, short x, short y, short dx, short dy) {
v[pos + 0] = x;
v[pos + 1] = y;
v[pos + 2] = dx;
v[pos + 3] = dy;
}
private VertexItem addVertex(VertexItem vertexItem,
float x, float y,
float vNextX, float vNextY,
float vPrevX, float vPrevY) {
float ux = vNextX + vPrevX;
float uy = vNextY + vPrevY;
/* vPrev times perpendicular of sum(vNext, vPrev) */
double a = uy * vPrevX - ux * vPrevY;
if (a < 0.01 && a > -0.01) {
ux = -vPrevY;
uy = vPrevX;
} else {
ux /= a;
uy /= a;
}
short ox = (short) (x * COORD_SCALE);
short oy = (short) (y * COORD_SCALE);
int ddx = (int) (ux * DIR_SCALE);
int ddy = (int) (uy * DIR_SCALE);
int opos = vertexItem.used;
short[] v = vertexItem.vertices;
if (opos == SIZE) {
vertexItem = pool.getNext(vertexItem);
v = vertexItem.vertices;
opos = 0;
}
v[opos + 0] = ox;
v[opos + 1] = oy;
v[opos + 2] = (short) (0 | ddx & DIR_MASK);
v[opos + 3] = (short) (1 | ddy & DIR_MASK);
if ((opos += 4) == SIZE) {
vertexItem = pool.getNext(vertexItem);
v = vertexItem.vertices;
opos = 0;
}
v[opos + 0] = ox;
v[opos + 1] = oy;
v[opos + 2] = (short) (2 | -ddx & DIR_MASK);
v[opos + 3] = (short) (1 | -ddy & DIR_MASK);
vertexItem.used = opos + 4;
return vertexItem;
}
private VertexItem addLine(VertexItem vertexItem, float[] points, int start, int length,
boolean rounded, boolean squared, boolean closed) {
float ux, uy;
float vPrevX, vPrevY;
float vNextX, vNextY;
float curX, curY;
float nextX, nextY;
double a;
short v[] = vertexItem.vertices;
int opos = vertexItem.used;
/* amount of vertices used /* amount of vertices used
* + 2 for drawing triangle-strip * + 2 for drawing triangle-strip
@ -183,87 +257,76 @@ public final class LineLayer extends RenderElement {
* + 2 for closing polygons */ * + 2 for closing polygons */
numVertices += length + (rounded ? 6 : 2) + (closed ? 2 : 0); numVertices += length + (rounded ? 6 : 2) + (closed ? 2 : 0);
int ipos = pos; int ipos = start;
x = points[ipos++]; curX = points[ipos++];
y = points[ipos++]; curY = points[ipos++];
nextX = points[ipos++]; nextX = points[ipos++];
nextY = points[ipos++]; nextY = points[ipos++];
/* Calculate triangle corners for the given width */
vx = nextX - x;
vy = nextY - y;
/* Unit vector to next node */ /* Unit vector to next node */
a = (float) Math.sqrt(vx * vx + vy * vy); vPrevX = nextX - curX;
vPrevY = nextY - curY;
vx /= a; a = (float) Math.sqrt(vPrevX * vPrevX + vPrevY * vPrevY);
vy /= a; vPrevX /= a;
vPrevY /= a;
/* perpendicular on the first segment */ /* perpendicular on the first segment */
ux = -vy; ux = -vPrevY;
uy = vx; uy = vPrevX;
int ddx, ddy; int ddx, ddy;
/* vertex point coordinate */ /* vertex point coordinate */
short ox = (short) (x * COORD_SCALE); short ox = (short) (curX * COORD_SCALE);
short oy = (short) (y * COORD_SCALE); short oy = (short) (curY * COORD_SCALE);
/* vertex extrusion vector, last two bit /* vertex extrusion vector, last two bit
* encode texture coord. */ * encode texture coord. */
short dx, dy; short dx, dy;
/* when the endpoint is outside the tile region omit round caps. */ /* when the endpoint is outside the tile region omit round caps. */
boolean outside = (x < tmin || x > tmax || y < tmin || y > tmax); boolean outside = (curX < tmin || curX > tmax || curY < tmin || curY > tmax);
if (opos == SIZE) { if (opos == SIZE) {
si = pool.getNext(si); vertexItem = pool.getNext(vertexItem);
v = si.vertices; v = vertexItem.vertices;
opos = 0; opos = 0;
} }
if (rounded && !outside) { if (rounded && !outside) {
/* add first vertex twice */ ddx = (int) ((ux - vPrevX) * DIR_SCALE);
ddx = (int) ((ux - vx) * DIR_SCALE); ddy = (int) ((uy - vPrevY) * DIR_SCALE);
ddy = (int) ((uy - vy) * DIR_SCALE);
dx = (short) (0 | ddx & DIR_MASK); dx = (short) (0 | ddx & DIR_MASK);
dy = (short) (2 | ddy & DIR_MASK); dy = (short) (2 | ddy & DIR_MASK);
v[opos++] = ox; addVertex(v, opos, ox, oy, dx, dy);
v[opos++] = oy;
v[opos++] = dx;
v[opos++] = dy;
if (opos == SIZE) { if ((opos += 4) == SIZE) {
si = pool.getNext(si); vertexItem = pool.getNext(vertexItem);
v = si.vertices; v = vertexItem.vertices;
opos = 0; opos = 0;
} }
v[opos++] = ox; addVertex(v, opos, ox, oy, dx, dy);
v[opos++] = oy;
v[opos++] = dx;
v[opos++] = dy;
if (opos == SIZE) { if ((opos += 4) == SIZE) {
si = pool.getNext(si); vertexItem = pool.getNext(vertexItem);
v = si.vertices; v = vertexItem.vertices;
opos = 0; opos = 0;
} }
ddx = (int) (-(ux + vx) * DIR_SCALE); ddx = (int) (-(ux + vPrevX) * DIR_SCALE);
ddy = (int) (-(uy + vy) * DIR_SCALE); ddy = (int) (-(uy + vPrevY) * DIR_SCALE);
v[opos++] = ox; addVertex(v, opos, ox, oy,
v[opos++] = oy; (short) (2 | ddx & DIR_MASK),
v[opos++] = (short) (2 | ddx & DIR_MASK); (short) (2 | ddy & DIR_MASK));
v[opos++] = (short) (2 | ddy & DIR_MASK);
if (opos == SIZE) { if ((opos += 4) == SIZE) {
si = pool.getNext(si); vertexItem = pool.getNext(vertexItem);
v = si.vertices; v = vertexItem.vertices;
opos = 0; opos = 0;
} }
@ -271,28 +334,26 @@ public final class LineLayer extends RenderElement {
ddx = (int) (ux * DIR_SCALE); ddx = (int) (ux * DIR_SCALE);
ddy = (int) (uy * DIR_SCALE); ddy = (int) (uy * DIR_SCALE);
v[opos++] = ox; addVertex(v, opos, ox, oy,
v[opos++] = oy; (short) (0 | ddx & DIR_MASK),
v[opos++] = (short) (0 | ddx & DIR_MASK); (short) (1 | ddy & DIR_MASK));
v[opos++] = (short) (1 | ddy & DIR_MASK);
if (opos == SIZE) { if ((opos += 4) == SIZE) {
si = pool.getNext(si); vertexItem = pool.getNext(vertexItem);
v = si.vertices; v = vertexItem.vertices;
opos = 0; opos = 0;
} }
v[opos++] = ox; addVertex(v, opos, ox, oy,
v[opos++] = oy; (short) (2 | -ddx & DIR_MASK),
v[opos++] = (short) (2 | -ddx & DIR_MASK); (short) (1 | -ddy & DIR_MASK));
v[opos++] = (short) (1 | -ddy & DIR_MASK);
} else { } else {
/* outside means line is probably clipped /* outside means line is probably clipped
* TODO should align ending with tile boundary * TODO should align ending with tile boundary
* for now, just extend the line a little */ * for now, just extend the line a little */
float tx = vx; float tx = vPrevX;
float ty = vy; float ty = vPrevY;
if (squared) { if (squared) {
tx = 0; tx = 0;
@ -311,74 +372,68 @@ public final class LineLayer extends RenderElement {
dx = (short) (0 | ddx & DIR_MASK); dx = (short) (0 | ddx & DIR_MASK);
dy = (short) (1 | ddy & DIR_MASK); dy = (short) (1 | ddy & DIR_MASK);
v[opos++] = ox; addVertex(v, opos, ox, oy, dx, dy);
v[opos++] = oy;
v[opos++] = dx;
v[opos++] = dy;
if (opos == SIZE) { if ((opos += 4) == SIZE) {
si = pool.getNext(si); vertexItem = pool.getNext(vertexItem);
v = si.vertices; v = vertexItem.vertices;
opos = 0; opos = 0;
} }
v[opos++] = ox; addVertex(v, opos, ox, oy, dx, dy);
v[opos++] = oy;
v[opos++] = dx;
v[opos++] = dy;
if (opos == SIZE) { if ((opos += 4) == SIZE) {
si = pool.getNext(si); vertexItem = pool.getNext(vertexItem);
v = si.vertices; v = vertexItem.vertices;
opos = 0; opos = 0;
} }
ddx = (int) (-(ux + tx) * DIR_SCALE); ddx = (int) (-(ux + tx) * DIR_SCALE);
ddy = (int) (-(uy + ty) * DIR_SCALE); ddy = (int) (-(uy + ty) * DIR_SCALE);
v[opos++] = ox; addVertex(v, opos, ox, oy,
v[opos++] = oy; (short) (2 | ddx & DIR_MASK),
v[opos++] = (short) (2 | ddx & DIR_MASK); (short) (1 | ddy & DIR_MASK));
v[opos++] = (short) (1 | ddy & DIR_MASK);
} }
x = nextX; curX = nextX;
y = nextY; curY = nextY;
/* Unit vector pointing back to previous node */ /* Unit vector pointing back to previous node */
vx *= -1; vPrevX *= -1;
vy *= -1; vPrevY *= -1;
int end = pos + length; vertexItem.used = opos + 4;
for (int end = start + length;;) {
for (;;) {
if (ipos < end) { if (ipos < end) {
nextX = points[ipos++]; nextX = points[ipos++];
nextY = points[ipos++]; nextY = points[ipos++];
} else if (closed && ipos < end + 2) { } else if (closed && ipos < end + 2) {
/* add startpoint == endpoint */ /* add startpoint == endpoint */
nextX = points[pos]; nextX = points[start];
nextY = points[pos + 1]; nextY = points[start + 1];
ipos += 2; ipos += 2;
} else } else
break; break;
/* Unit vector pointing forward to next node */ /* unit vector pointing forward to next node */
wx = nextX - x; vNextX = nextX - curX;
wy = nextY - y; vNextY = nextY - curY;
a = Math.sqrt(wx * wx + wy * wy); a = Math.sqrt(vNextX * vNextX + vNextY * vNextY);
/* skip too short segmets */ /* skip too short segmets */
if (a < mMinDist) { if (a < mMinDist) {
numVertices -= 2; numVertices -= 2;
continue; continue;
} }
wx /= a; vNextX /= a;
wy /= a; vNextY /= a;
double dotp = (wx * vx + wy * vy); double dotp = (vNextX * vPrevX + vNextY * vPrevY);
//log.debug("acos " + dotp); //log.debug("acos " + dotp);
if (dotp > 0.7) { if (dotp > 0.65) {
/* add bevel join to avoid miter going to infinity */ /* add bevel join to avoid miter going to infinity */
numVertices += 2; numVertices += 2;
@ -390,271 +445,163 @@ public final class LineLayer extends RenderElement {
float px, py; float px, py;
if (dotp > 0.999) { if (dotp > 0.999) {
/* 360 degree angle, set points aside */ /* 360 degree angle, set points aside */
ux = vx + wx; ux = vPrevX + vNextX;
uy = vy + wy; uy = vPrevY + vNextY;
a = wx * uy - wy * ux; a = vNextX * uy - vNextY * ux;
if (a < 0.1 && a > -0.1) { if (a < 0.1 && a > -0.1) {
/* Almost straight */ /* Almost straight */
ux = -wy; ux = -vNextY;
uy = wx; uy = vNextX;
} else { } else {
ux /= a; ux /= a;
uy /= a; uy /= a;
} }
//log.debug("aside " + a + " " + ux + " " + uy); //log.debug("aside " + a + " " + ux + " " + uy);
px = x - ux * MIN_DIST * 2; px = curX - ux * BEVEL_MIN;
py = y - uy * MIN_DIST * 2; py = curY - uy * BEVEL_MIN;
x = x + ux * MIN_DIST * 2; curX = curX + ux * BEVEL_MIN;
y = y + uy * MIN_DIST * 2; curY = curY + uy * BEVEL_MIN;
} else { } else {
//log.debug("back"); //log.debug("back");
/* go back by min dist */ /* go back by min dist */
px = x + vx * MIN_DIST * 2; px = curX + vPrevX * BEVEL_MIN;
py = y + vy * MIN_DIST * 2; py = curY + vPrevY * BEVEL_MIN;
/* go forward by min dist */ /* go forward by min dist */
x = x + wx * MIN_DIST * 2; curX = curX + vNextX * BEVEL_MIN;
y = y + wy * MIN_DIST * 2; curY = curY + vNextY * BEVEL_MIN;
} }
/* Unit vector pointing forward to next node */ /* unit vector pointing forward to next node */
wx = x - px; vNextX = curX - px;
wy = y - py; vNextY = curY - py;
a = Math.sqrt(wx * wx + wy * wy); a = Math.sqrt(vNextX * vNextX + vNextY * vNextY);
wx /= a; vNextX /= a;
wy /= a; vNextY /= a;
ux = vx + wx; vertexItem = addVertex(vertexItem, px, py, vPrevX, vPrevY, vNextX, vNextY);
uy = vy + wy;
a = wx * uy - wy * ux;
if (a < 0.01 && a > -0.01) {
ux = -wy;
uy = wx;
} else {
ux /= a;
uy /= a;
}
ox = (short) (px * COORD_SCALE);
oy = (short) (py * COORD_SCALE);
ddx = (int) (ux * DIR_SCALE);
ddy = (int) (uy * DIR_SCALE);
if (opos == SIZE) {
si = pool.getNext(si);
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 == SIZE) {
si = pool.getNext(si);
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);
/* flip unit vector to point back */ /* flip unit vector to point back */
vx = -wx; vPrevX = -vNextX;
vy = -wy; vPrevY = -vNextY;
/* Unit vector pointing forward to next node */ /* unit vector pointing forward to next node */
wx = nextX - x; vNextX = nextX - curX;
wy = nextY - y; vNextY = nextY - curY;
a = Math.sqrt(wx * wx + wy * wy); a = Math.sqrt(vNextX * vNextX + vNextY * vNextY);
wx /= a; vNextX /= a;
wy /= a; vNextY /= a;
} }
ux = vx + wx; vertexItem = addVertex(vertexItem, curX, curY, vPrevX, vPrevY, vNextX, vNextY);
uy = vy + wy;
a = wx * uy - wy * ux;
if (a < 0.01 && a > -0.01) { curX = nextX;
/* Almost straight */ curY = nextY;
ux = -wy;
uy = wx; /* flip vector to point back */
} else { vPrevX = -vNextX;
ux /= a; vPrevY = -vNextY;
uy /= a;
} }
ox = (short) (x * COORD_SCALE); opos = vertexItem.used;
oy = (short) (y * COORD_SCALE); v = vertexItem.vertices;
ddx = (int) (ux * DIR_SCALE); ux = vPrevY;
ddy = (int) (uy * DIR_SCALE); uy = -vPrevX;
outside = (curX < tmin || curX > tmax || curY < tmin || curY > tmax);
if (opos == SIZE) { if (opos == SIZE) {
si = pool.getNext(si); vertexItem = pool.getNext(vertexItem);
v = si.vertices; v = vertexItem.vertices;
opos = 0; opos = 0;
} }
v[opos++] = ox; ox = (short) (curX * COORD_SCALE);
v[opos++] = oy; oy = (short) (curY * COORD_SCALE);
v[opos++] = (short) (0 | ddx & DIR_MASK);
v[opos++] = (short) (1 | ddy & DIR_MASK);
if (opos == SIZE) {
si = pool.getNext(si);
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 == SIZE) {
si = pool.getNext(si);
opos = 0;
v = si.vertices;
}
ox = (short) (x * COORD_SCALE);
oy = (short) (y * COORD_SCALE);
if (rounded && !outside) { if (rounded && !outside) {
ddx = (int) (ux * DIR_SCALE); ddx = (int) (ux * DIR_SCALE);
ddy = (int) (uy * DIR_SCALE); ddy = (int) (uy * DIR_SCALE);
v[opos++] = ox; addVertex(v, opos, ox, oy,
v[opos++] = oy; (short) (0 | ddx & DIR_MASK),
v[opos++] = (short) (0 | ddx & DIR_MASK); (short) (1 | ddy & DIR_MASK));
v[opos++] = (short) (1 | ddy & DIR_MASK);
if (opos == SIZE) { if ((opos += 4) == SIZE) {
si = pool.getNext(si); vertexItem = pool.getNext(vertexItem);
v = si.vertices; v = vertexItem.vertices;
opos = 0; opos = 0;
} }
v[opos++] = ox; addVertex(v, opos, ox, oy,
v[opos++] = oy; (short) (2 | -ddx & DIR_MASK),
v[opos++] = (short) (2 | -ddx & DIR_MASK); (short) (1 | -ddy & DIR_MASK));
v[opos++] = (short) (1 | -ddy & DIR_MASK);
if (opos == SIZE) { if ((opos += 4) == SIZE) {
si = pool.getNext(si); vertexItem = pool.getNext(vertexItem);
v = si.vertices; v = vertexItem.vertices;
opos = 0; opos = 0;
} }
/* For rounded line edges */ /* For rounded line edges */
ddx = (int) ((ux - vx) * DIR_SCALE); ddx = (int) ((ux - vPrevX) * DIR_SCALE);
ddy = (int) ((uy - vy) * DIR_SCALE); ddy = (int) ((uy - vPrevY) * DIR_SCALE);
dx = (short) (0 | ddx & DIR_MASK); addVertex(v, opos, ox, oy,
dy = (short) (0 | ddy & DIR_MASK); (short) (0 | ddx & DIR_MASK),
(short) (0 | ddy & DIR_MASK));
v[opos++] = ox; /* last vertex */
v[opos++] = oy; ddx = (int) (-(ux + vPrevX) * DIR_SCALE);
v[opos++] = dx; ddy = (int) (-(uy + vPrevY) * DIR_SCALE);
v[opos++] = dy;
if (opos == SIZE) {
si = pool.getNext(si);
v = si.vertices;
opos = 0;
}
/* add last vertex twice */
ddx = (int) (-(ux + vx) * DIR_SCALE);
ddy = (int) (-(uy + vy) * DIR_SCALE);
dx = (short) (2 | ddx & DIR_MASK); dx = (short) (2 | ddx & DIR_MASK);
dy = (short) (0 | ddy & DIR_MASK); dy = (short) (0 | ddy & DIR_MASK);
v[opos++] = ox;
v[opos++] = oy;
v[opos++] = dx;
v[opos++] = dy;
if (opos == SIZE) {
si = pool.getNext(si);
v = si.vertices;
opos = 0;
}
v[opos++] = ox;
v[opos++] = oy;
v[opos++] = dx;
v[opos++] = dy;
} else { } else {
if (squared) { if (squared) {
vx = 0; vPrevX = 0;
vy = 0; vPrevY = 0;
} else if (!outside) { } else if (!outside) {
vx *= 0.5; vPrevX *= 0.5;
vy *= 0.5; vPrevY *= 0.5;
} }
if (rounded) if (rounded)
numVertices -= 2; numVertices -= 2;
ddx = (int) ((ux - vx) * DIR_SCALE); ddx = (int) ((ux - vPrevX) * DIR_SCALE);
ddy = (int) ((uy - vy) * DIR_SCALE); ddy = (int) ((uy - vPrevY) * DIR_SCALE);
v[opos++] = ox; addVertex(v, opos, ox, oy,
v[opos++] = oy; (short) (0 | ddx & DIR_MASK),
v[opos++] = (short) (0 | ddx & DIR_MASK); (short) (1 | ddy & DIR_MASK));
v[opos++] = (short) (1 | ddy & DIR_MASK);
if (opos == SIZE) { /* last vertex */
si = pool.getNext(si); ddx = (int) (-(ux + vPrevX) * DIR_SCALE);
v = si.vertices; ddy = (int) (-(uy + vPrevY) * DIR_SCALE);
opos = 0; dx = (short) (2 | ddx & DIR_MASK);
dy = (short) (1 | ddy & DIR_MASK);
} }
/* add last vertex twice */ /* add last vertex twice */
ddx = (int) (-(ux + vx) * DIR_SCALE); if ((opos += 4) == SIZE) {
ddy = (int) (-(uy + vy) * DIR_SCALE); vertexItem = pool.getNext(vertexItem);
dx = (short) (2 | ddx & DIR_MASK); v = vertexItem.vertices;
dy = (short) (1 | ddy & DIR_MASK);
v[opos++] = ox;
v[opos++] = oy;
v[opos++] = dx;
v[opos++] = dy;
if (opos == SIZE) {
si = pool.getNext(si);
v = si.vertices;
opos = 0; opos = 0;
} }
v[opos++] = ox; addVertex(v, opos, ox, oy, dx, dy);
v[opos++] = oy;
v[opos++] = dx;
v[opos++] = dy;
}
pos += length;
}
si.used = opos; if ((opos += 4) == SIZE) {
vertexItem = pool.getNext(vertexItem);
v = vertexItem.vertices;
opos = 0;
}
addVertex(v, opos, ox, oy, dx, dy);
vertexItem.used = opos + 4;
return vertexItem;
} }
public static final class Renderer { public static final class Renderer {