/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @author Denis M. Kishenko
* @version $Revision$
*/
package org.apache.harmony.awt.gl.render;
import org.apache.harmony.awt.gl.MultiRectArea;
public class JavaLineRasterizer {
/**
* LineDasher class provides dashing for particular dash style
*/
public static class LineDasher {
int index;
float pos;
float phase;
float dash[];
float inv[];
boolean visible;
public LineDasher() {
}
public LineDasher(float dash[], float phase) {
this.dash = dash;
this.phase = phase;
inv = new float[dash.length];
int j = dash.length;
for (float element : dash) {
inv[--j] = element;
}
index = 0;
while (phase > dash[index]) {
phase -= dash[index];
index = (index + 1) % dash.length;
}
visible = index % 2 == 0;
}
void move(float step) { // main dasher
pos += step;
step += phase;
while(step >= dash[index]) {
step -= dash[index];
index = (index + 1) % dash.length;
visible = !visible;
}
phase = step;
}
float nextDash() {
phase = 0.0f;
index = (index + 1) % dash.length;
visible = !visible;
return dash[index];
}
LineDasher createDiagonal(double k, float length, boolean invert) {
LineDasher local = new LineDasher();
local.dash = new float[dash.length];
if (invert) { // inverted dasher
move(length);
local.phase = (float)((dash[index] - phase) * k);
local.visible = visible;
local.index = inv.length - index - 1;
for(int i = 0; i < inv.length; i++) {
local.dash[i] = (float)(inv[i] * k);
}
} else {
local.phase = (float)(phase * k);
local.visible = visible;
local.index = index;
for(int i = 0; i < dash.length; i++) {
local.dash[i] = (float)(dash[i] * k);
}
move(length);
}
return local;
}
LineDasher createOrtogonal(float length, boolean invert) {
LineDasher local = new LineDasher();
local.dash = new float[dash.length];
if (invert) { // inverted dasher
move(length);
local.phase = dash[index] - phase;
local.visible = visible;
local.index = inv.length - index - 1;
local.dash = inv;
} else {
local.phase = phase;
local.visible = visible;
local.index = index;
local.dash = dash;
move(length);
}
return local;
}
LineDasher createChild(float start) {
LineDasher child = new LineDasher();
child.phase = phase;
child.visible = visible;
child.index = index;
child.dash = dash;
child.move(start);
return child;
}
}
/**
* Line class provides rasterization for different line types
*/
abstract static class Line {
int x1, y1, x2, y2;
int x, y;
MultiRectArea dst;
Line(int x1, int y1, int x2, int y2, MultiRectArea dst) {
this.x1 = x1;
this.y1 = y1;
this.x2 = x2;
this.y2 = y2;
this.dst = dst;
}
static abstract class Diag extends Line {
int dx, dy, adx, ady, sx, sy;
int eBase, ePos, eNeg;
int xcount;
int e;
Diag(int x1, int y1, int x2, int y2, MultiRectArea dst) {
super(x1, y1, x2, y2, dst);
dx = x2 - x1;
dy = y2 - y1;
sy = 1;
if (dx > 0) {
adx = dx;
sx = 1;
} else {
adx = -dx;
sx = -1;
}
ady = dy;
}
float getLength() {
return (float)Math.sqrt(dx * dx + dy * dy);
}
static class Hor extends Diag {
Hor(int x1, int y1, int x2, int y2, MultiRectArea dst) {
super(x1, y1, x2, y2, dst);
eBase = ady + ady - adx;
ePos = 2 * (ady - adx);
eNeg = ady + ady;
xcount = adx;
}
@Override
void rasterize() {
e = eBase;
x = x1;
y = y1;
rasterize(xcount);
}
@Override
void rasterizeClipped(int nx1, int ny1, int nx2, int ny2) {
e = eBase + 2 * (ady * Math.abs(nx1 - x1) - adx * Math.abs(ny1 - y1));
x = nx1;
y = ny1;
rasterize(dx > 0 ? nx2 - nx1 : nx1 - nx2);
}
@Override
void rasterize(int count) {
int px = x;
while (count-- > 0) {
if (e >= 0) {
if (sx > 0) {
dst.addRect(px, y, x, y);
} else {
dst.addRect(x, y, px, y);
}
x += sx;
y += sy;
e += ePos;
px = x;
} else {
e += eNeg;
x += sx;
}
}
if (sx > 0) {
dst.addRect(px, y, x, y);
} else {
dst.addRect(x, y, px, y);
}
}
@Override
void skip(int count) {
while (count-- > 0) {
x += sx;
if (e >= 0) {
y += sy;
e += ePos;
} else {
e += eNeg;
}
}
}
}
static class Ver extends Diag {
Ver(int x1, int y1, int x2, int y2, MultiRectArea dst) {
super(x1, y1, x2, y2, dst);
eBase = adx + adx - ady;
ePos = 2 * (adx - ady);
eNeg = adx + adx;
xcount = ady;
}
@Override
void rasterize() {
e = eBase;
x = x1;
y = y1;
rasterize(xcount);
}
@Override
void rasterizeClipped(int nx1, int ny1, int nx2, int ny2) {
e = eBase + 2 * (adx * Math.abs(ny1 - y1) - ady * Math.abs(nx1 - x1));
x = nx1;
y = ny1;
rasterize(ny2 - ny1);
}
@Override
void rasterize(int count) {
int py = y;
while (count-- > 0) {
if (e >= 0) {
dst.addRect(x, py, x, y);
x += sx;
y += sy;
e += ePos;
py = y;
} else {
y += sy;
e += eNeg;
}
}
dst.addRect(x, py, x, y);
}
@Override
void skip(int count) {
while (count-- > 0) {
y += sy;
if (e >= 0) {
x += sx;
e += ePos;
} else {
e += eNeg;
}
}
}
}
static class HorDashed extends Hor {
LineDasher local;
HorDashed(int x1, int y1, int x2, int y2, MultiRectArea dst, LineDasher dasher, boolean invert) {
super(x1, y1, x2, y2, dst);
float length = getLength();
local = dasher.createDiagonal(xcount / length, length, invert);
}
@Override
void rasterize() {
e = eBase;
x = x1;
y = y1;
rasterizeDash(xcount, local);
}
@Override
void rasterizeClipped(int nx1, int ny1, int nx2, int ny2) {
e = eBase + 2 * (ady * Math.abs(nx1 - x1) - adx * Math.abs(ny1 - y1));
x = nx1;
y = ny1;
rasterizeDash(Math.abs(nx2 - nx1), local.createChild(Math.abs(nx1 - x1)));
}
}
static class VerDashed extends Ver {
LineDasher local;
VerDashed(int x1, int y1, int x2, int y2, MultiRectArea dst, LineDasher dasher, boolean invert) {
super(x1, y1, x2, y2, dst);
float length = getLength();
local = dasher.createDiagonal(xcount / length, length, invert);
}
@Override
void rasterize() {
e = eBase;
x = x1;
y = y1;
rasterizeDash(xcount, local);
}
@Override
void rasterizeClipped(int nx1, int ny1, int nx2, int ny2) {
e = eBase + 2 * (adx * Math.abs(ny1 - y1) - ady * Math.abs(nx1 - x1));
x = nx1;
y = ny1;
rasterizeDash(ny2 - ny1, local.createChild(ny1 - y1));
}
}
@Override
void rasterize(int[] clip, int index) {
int cx1 = clip[index + 0];
int cy1 = clip[index + 1];
int cx2 = clip[index + 2] + 1;
int cy2 = clip[index + 3] + 1;
int code1 =
(x1 < cx1 ? 1 : 0) | (x1 >= cx2 ? 2 : 0) |
(y1 < cy1 ? 8 : 0) | (y1 >= cy2 ? 4 : 0);
int code2 =
(x2 < cx1 ? 1 : 0) | (x2 >= cx2 ? 2 : 0) |
(y2 < cy1 ? 8 : 0) | (y2 >= cy2 ? 4 : 0);
// Outside
if ((code1 & code2) != 0) {
return;
}
// Inside
if (code1 == 0 && code2 == 0) {
rasterize();
return;
}
// Clip
int nx1 = x1;
int ny1 = y1;
int nx2 = x2;
int ny2 = y2;
// need to clip
cx1 -= x1; cx2 -= x1;
cy1 -= y1; cy2 -= y1;
// int d;
int newx1 = 0, newy1 = 0, newx2 = 0, newy2 = 0;
if (code1 != 0) {
newx1 = Integer.MAX_VALUE;
if ((code1 & 8) != 0) {
// clip point 1 with top clip bound
newy1 = cy1;
newx1 = clipY(dx, dy, newy1, true);
} else if ((code1 & 4) != 0) {
// clip point 1 with bottom clip bound
newy1 = cy2 - 1;
newx1 = clipY(dx, dy, newy1, false);
}
if ((code1 & 1) != 0 && (cx1 > newx1 || newx1 == Integer.MAX_VALUE)) {
// clip point 1 with left clip bound
newx1 = cx1;
newy1 = clipX(dx, dy, newx1, false);
} else if ((code1 & 2) != 0 && (newx1 >= cx2 || newx1 == Integer.MAX_VALUE)) {
// clip point 1 with right clip bound
newx1 = cx2 - 1;
newy1 = clipX(dx, dy, newx1, false);
}
if (newx1 < cx1 || newx1 >= cx2 || newy1 < cy1 || newy1 >= cy2) {
return;
}
// d = 2 * (ady * Math.abs(newx1) - adx * Math.abs(newy1)) + 2 * ady - adx;
} else {
// d = (ady << 1) - adx;
}
if (code2 != 0) {
newx2=Integer.MAX_VALUE;
if ((code2 & 8) != 0) {
// clip point 2 with top clip bound
newy2 = cy1;
newx2 = clipY(dx, dy, newy2, true);
} else if ((code2 & 4) != 0) {
// clip point 2 with bottom clip bound
newy2 = cy2 - 1;
newx2 = clipY(dx, dy, newy2, false);
}
if ((code2 & 1) != 0 && (cx1 > newx2 || newx2 == Integer.MAX_VALUE)) {
// clip point 2 with left clip bound
newx2 = cx1;
newy2 = clipX(dx, dy, newx2, false);
} else if ((code2 & 2) != 0 && (newx2 >= cx2 || newx2 == Integer.MAX_VALUE)) {
// clip point 2 with right clip bound
newx2 = cx2 - 1;
newy2 = clipX(dx, dy, newx2, false);
}
if (newx2 < cx1 || newx2 >= cx2 || newy2 < cy1 || newy2 >= cy2) {
return;
}
nx2 = x1 + newx2;
ny2 = y1 + newy2;
}
nx1 = x1 + newx1;
ny1 = y1 + newy1;
rasterizeClipped(nx1, ny1, nx2, ny2);
}
abstract void rasterizeClipped(int nx1, int ny1, int nx2, int ny2);
}
static abstract class Ortog extends Line {
Ortog(int x1, int y1, int x2, int y2, MultiRectArea dst) {
super(x1, y1, x2, y2, dst);
}
static class Hor extends Ortog {
int dx;
Hor(int x1, int y1, int x2, int y2, MultiRectArea dst) {
super(x1, y1, x2, y2, dst);
dx = x2 - x1;
}
@Override
void rasterize() {
if (dx > 0) {
dst.addRect(x1, y1, x2, y2);
} else {
dst.addRect(x2, y2, x1, y1);
}
}
@Override
void rasterize(int step) {
int px = x;
if (dx > 0) {
x += step;
dst.addRect(px, y1, x - 1, y2);
} else {
x -= step;
dst.addRect(x + 1, y2, px, y1);
}
}
@Override
void skip(int step) {
if (dx > 0) {
x += step;
} else {
x -= step;
}
}
void rasterizeClipped(int nx1, int nx2) {
if (nx1 < nx2) {
dst.addRect(nx1, y1, nx2, y1);
} else {
dst.addRect(nx2, y1, nx1, y1);
}
}
@Override
void rasterize(int[] clip, int index) {
if (y1 >= clip[index + 1] && y1 <= clip[index + 3]) {
int cx1 = clip[index + 0];
int cx2 = clip[index + 2];
if (x1 <= cx2 && x2 >= cx1) {
int nx1, nx2;
if (dx > 0) {
nx1 = Math.max(x1, cx1);
nx2 = Math.min(x2, cx2);
} else {
nx2 = Math.max(x2, cx1);
nx1 = Math.min(x1, cx2);
}
rasterizeClipped(nx1, nx2);
}
}
}
}
static class Ver extends Ortog {
int dy;
Ver(int x1, int y1, int x2, int y2, MultiRectArea dst) {
super(x1, y1, x2, y2, dst);
dy = y2 - y1;
}
@Override
void rasterize() {
dst.addRect(x1, y1, x2, y2);
}
@Override
void rasterize(int step) {
int py = y;
y += step;
dst.addRect(x1, py, x2, y - 1);
}
@Override
void skip(int step) {
y += step;
}
void rasterizeClipped(int ny1, int ny2) {
dst.addRect(x1, ny1, x1, ny2);
}
@Override
void rasterize(int[] clip, int index) {
if (x1 >= clip[index] && x1 <= clip[index + 2]) {
int cy1 = clip[index + 1];
int cy2 = clip[index + 3];
if (y1 <= cy2 && y2 >= cy1) {
rasterizeClipped(Math.max(y1, cy1), Math.min(y2, cy2));
}
}
}
}
static class HorDashed extends Hor {
LineDasher local;
HorDashed(int x1, int y1, int x2, int y2, MultiRectArea dst, LineDasher dasher) {
super(x1, y1, x2, y2, dst);
dx = x2 - x1;
local = dasher.createOrtogonal(Math.abs(dx), false);
}
@Override
void rasterize() {
x = x1;
y = y1;
rasterizeDash(Math.abs(dx), local);
}
@Override
void rasterizeClipped(int nx1, int nx2) {
x = nx1;
y = y1;
rasterizeDash(Math.abs(nx2 - nx1), local.createChild(Math.abs(nx1 - x1)));
}
}
static class VerDashed extends Ver {
LineDasher local;
VerDashed(int x1, int y1, int x2, int y2, MultiRectArea dst, LineDasher dasher, boolean invert) {
super(x1, y1, x2, y2, dst);
dy = y2 - y1;
local = dasher.createOrtogonal(dy, invert);
}
@Override
void rasterize() {
x = x1;
y = y1;
rasterizeDash(dy, local);
}
@Override
void rasterizeClipped(int ny1, int ny2) {
x = x1;
y = ny1;
rasterizeDash(ny2 - ny1, local.createChild(ny1));
}
}
}
abstract void rasterize();
abstract void rasterize(int[] clip, int index);
abstract void rasterize(int count);
abstract void skip(int count);
void rasterizeDash(int count, LineDasher dasher) {
float delta = dasher.dash[dasher.index] - dasher.phase;
int step = (int)delta;
delta -= step;
while(count > step) {
if (dasher.visible) {
rasterize(step);
} else {
skip(step);
}
count -= step;
delta += dasher.nextDash();
step = (int)delta;
delta -= step;
}
if (count > 0 && dasher.visible) {
rasterize(count);
dasher.move(count);
}
}
}
/**
* Common clipping method
*/
static int clip(int dX1, int dX2, int cX, boolean top) {
int adX1 = dX1 < 0 ? -dX1 : dX1;
int adX2 = dX2 < 0 ? -dX2 : dX2;
if (adX1 <= adX2) {
// obtuse intersection angle
return ((dX1 << 1) * cX + (dX1 > 0 ? dX2 : -dX2)) / (dX2 << 1);
}
int k;
if (top) {
k = -dX1 + (dX2 < 0 ? 0 : dX1 > 0 ? (dX2 << 1) : -(dX2 << 1));
} else {
k = dX1 + (dX2 > 0 ? 0 : dX1 > 0 ? (dX2 << 1) : -(dX2 << 1));
}
k += dX1 > 0 == dX2 > 0 ? -1 : 1;
return ((dX1 << 1) * cX + k) / (dX2 << 1);
}
/**
* Clipping along X axis
*/
static int clipX(int dx, int dy, int cy, boolean top) {
return clip(dy, dx, cy, top);
}
/**
* Clipping along Y axis
*/
static int clipY(int dx, int dy, int cx, boolean top) {
return clip(dx, dy, cx, top);
}
/**
* Rasterizes line using clippind and dashing style
* @param x1 - the x coordinate of the first control point
* @param y1 - the y coordinate of the first control point
* @param x2 - the x coordinate of the second control point
* @param y2 - the y coordinate of the second control point
* @param clip - the MultiRectArea object of clipping area
* @param dasher - the dasher style
* @param invert - the invert indicator, always false
* @return a MultiRectArea of rasterizer line
*/
public static MultiRectArea rasterize(int x1, int y1, int x2, int y2, MultiRectArea clip, LineDasher dasher, boolean invert) {
MultiRectArea dst = new MultiRectArea(false);
int dx = x2 - x1;
int dy = y2 - y1;
// Point
if (dx == 0 && dy == 0) {
if ((clip == null || clip.contains(x1, y1)) && (dasher == null || dasher.visible)) {
dst = new MultiRectArea(x1, y1, x1, y1);
}
return dst;
}
if (dy < 0) {
return rasterize(x2, y2, x1, y1, clip, dasher, true);
}
Line line;
if (dasher == null) {
if (dx == 0) {
line = new Line.Ortog.Ver(x1, y1, x2, y2, dst);
} else
if (dy == 0) {
line = new Line.Ortog.Hor(x1, y1, x2, y2, dst);
} else {
if (dy < Math.abs(dx)) {
line = new Line.Diag.Hor(x1, y1, x2, y2, dst);
} else {
line = new Line.Diag.Ver(x1, y1, x2, y2, dst);
}
}
} else {
if (dx == 0) {
line = new Line.Ortog.VerDashed(x1, y1, x2, y2, dst, dasher, invert);
} else
if (dy == 0) {
line = new Line.Ortog.HorDashed(x1, y1, x2, y2, dst, dasher);
} else {
if (dy < Math.abs(dx)) {
line = new Line.Diag.HorDashed(x1, y1, x2, y2, dst, dasher, invert);
} else {
line = new Line.Diag.VerDashed(x1, y1, x2, y2, dst, dasher, invert);
}
}
}
if (clip == null || clip.isEmpty()) {
line.rasterize();
} else {
for(int i = 1; i < clip.rect[0]; i += 4) {
line.rasterize(clip.rect, i);
}
}
return dst;
}
}