Ondřej Hruška
10 years ago
parent
e3e77dc308
commit
950943e01c
@ -1,854 +0,0 @@ |
||||
package mightypork.gamecore.gui.constraints; |
||||
|
||||
|
||||
import mightypork.gamecore.control.timing.Poller; |
||||
import mightypork.gamecore.input.InputSystem; |
||||
import mightypork.gamecore.render.DisplaySystem; |
||||
import mightypork.utils.math.coord.Coord; |
||||
import mightypork.utils.math.coord.Rect; |
||||
|
||||
|
||||
/** |
||||
* Constraint factory.<br> |
||||
* Import statically for best experience. |
||||
* |
||||
* @author MightyPork |
||||
*/ |
||||
public class Constraints { |
||||
|
||||
/* ================= Variables ================= */ |
||||
|
||||
public static final NumberConstraint _mouseX = new NumberConstraint() { |
||||
|
||||
@Override |
||||
public double getValue() |
||||
{ |
||||
return InputSystem.getMousePos().x(); |
||||
} |
||||
}; |
||||
|
||||
public static final NumberConstraint _mouseY = new NumberConstraint() { |
||||
|
||||
@Override |
||||
public double getValue() |
||||
{ |
||||
return InputSystem.getMousePos().y(); |
||||
} |
||||
}; |
||||
|
||||
public static final NumberConstraint _screenW = new NumberConstraint() { |
||||
|
||||
@Override |
||||
public double getValue() |
||||
{ |
||||
return DisplaySystem.getWidth(); |
||||
} |
||||
}; |
||||
|
||||
public static final NumberConstraint _screenH = new NumberConstraint() { |
||||
|
||||
@Override |
||||
public double getValue() |
||||
{ |
||||
return DisplaySystem.getHeight(); |
||||
} |
||||
}; |
||||
|
||||
|
||||
/* ================= Arithmetics ================= */ |
||||
|
||||
public static NumberConstraint _min(final Object a, final Object b) |
||||
{ |
||||
return new NumberConstraint() { |
||||
|
||||
@Override |
||||
public double getValue() |
||||
{ |
||||
return Math.min(_nv(a), _nv(b)); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static NumberConstraint _max(final Object a, final Object b) |
||||
{ |
||||
return new NumberConstraint() { |
||||
|
||||
@Override |
||||
public double getValue() |
||||
{ |
||||
return Math.max(_nv(a), _nv(b)); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static NumberConstraint _abs(final NumberConstraint a) |
||||
{ |
||||
return new NumberConstraint() { |
||||
|
||||
@Override |
||||
public double getValue() |
||||
{ |
||||
return Math.abs(a.getValue()); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static NumberConstraint _half(final NumberConstraint a) |
||||
{ |
||||
return new NumberConstraint() { |
||||
|
||||
@Override |
||||
public double getValue() |
||||
{ |
||||
return a.getValue() / 2; |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static NumberConstraint _round(final NumberConstraint a) |
||||
{ |
||||
return new NumberConstraint() { |
||||
|
||||
@Override |
||||
public double getValue() |
||||
{ |
||||
return Math.round(a.getValue()); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _round(final RectConstraint r) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
return r.getRect().round(); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static NumberConstraint _ceil(final NumberConstraint a) |
||||
{ |
||||
return new NumberConstraint() { |
||||
|
||||
@Override |
||||
public double getValue() |
||||
{ |
||||
return Math.ceil(a.getValue()); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static NumberConstraint _floor(final NumberConstraint a) |
||||
{ |
||||
return new NumberConstraint() { |
||||
|
||||
@Override |
||||
public double getValue() |
||||
{ |
||||
return Math.floor(a.getValue()); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static NumberConstraint _neg(final NumberConstraint a) |
||||
{ |
||||
return new NumberConstraint() { |
||||
|
||||
@Override |
||||
public double getValue() |
||||
{ |
||||
return -a.getValue(); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static NumberConstraint _add(final Object a, final Object b) |
||||
{ |
||||
return new NumberConstraint() { |
||||
|
||||
@Override |
||||
public double getValue() |
||||
{ |
||||
return _nv(a) + _nv(b); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static NumberConstraint _sub(final Object a, final Object b) |
||||
{ |
||||
return new NumberConstraint() { |
||||
|
||||
@Override |
||||
public double getValue() |
||||
{ |
||||
return _nv(a) - _nv(b); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static NumberConstraint _mul(final Object a, final Object b) |
||||
{ |
||||
return new NumberConstraint() { |
||||
|
||||
@Override |
||||
public double getValue() |
||||
{ |
||||
return _nv(a) * _nv(b); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static NumberConstraint _div(final Object a, final Object b) |
||||
{ |
||||
return new NumberConstraint() { |
||||
|
||||
@Override |
||||
public double getValue() |
||||
{ |
||||
return _nv(a) / _nv(b); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static NumberConstraint _percent(final Object whole, final Object percent) |
||||
{ |
||||
return new NumberConstraint() { |
||||
|
||||
@Override |
||||
public double getValue() |
||||
{ |
||||
return _nv(whole) * (_nv(percent) / 100); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static NumberConstraint _width(final RectConstraint r) |
||||
{ |
||||
return new NumberConstraint() { |
||||
|
||||
@Override |
||||
public double getValue() |
||||
{ |
||||
return r.getRect().getSize().x(); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static NumberConstraint _height(final RectConstraint r) |
||||
{ |
||||
return new NumberConstraint() { |
||||
|
||||
@Override |
||||
public double getValue() |
||||
{ |
||||
return r.getRect().getSize().y(); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
/* ================= Layout utilities ================= */ |
||||
|
||||
public static RectConstraint _row(final RectConstraint r, final int rows, final int index) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
final double height = r.getRect().getSize().y(); |
||||
final double perRow = height / rows; |
||||
|
||||
final Coord origin = r.getRect().getOrigin().add(0, perRow * index); |
||||
final Coord size = r.getRect().getSize().setY(perRow); |
||||
|
||||
return Rect.fromSize(origin, size); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _column(final RectConstraint r, final int columns, final int index) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
final double width = r.getRect().getSize().x(); |
||||
final double perCol = width / columns; |
||||
|
||||
final Coord origin = r.getRect().getOrigin().add(perCol * index, 0); |
||||
final Coord size = r.getRect().getSize().setX(perCol); |
||||
|
||||
return Rect.fromSize(origin, size); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _tile(final RectConstraint r, final int rows, final int cols, final int left, final int top) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
final double height = r.getRect().getSize().y(); |
||||
final double width = r.getRect().getSize().y(); |
||||
final double perRow = height / rows; |
||||
final double perCol = width / cols; |
||||
|
||||
final Coord origin = r.getRect().getOrigin().add(perCol * left, perRow * (rows - top - 1)); |
||||
|
||||
return Rect.fromSize(origin, perCol, perRow); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
/* ================= Rect manipulation ================= */ |
||||
|
||||
public static RectConstraint _shrink(RectConstraint r, Object shrink) |
||||
{ |
||||
final NumberConstraint n = _n(shrink); |
||||
return _shrink(r, n, n, n, n); |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _shrink(RectConstraint context, Object horiz, Object vert) |
||||
{ |
||||
return _shrink(context, horiz, vert, horiz, vert); |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _shrink(final RectConstraint r, final Object xmin, final Object ymin, final Object xmax, final Object ymax) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
return r.getRect().shrink(_nv(xmin), _nv(ymin), _nv(xmax), _nv(ymax)); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _shrink_top(final RectConstraint r, final Object shrink) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
return r.getRect().shrink(0, _nv(shrink), 0, 0); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _shrink_bottom(final RectConstraint r, final Object shrink) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
return r.getRect().shrink(0, 0, 0, _nv(shrink)); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _shrink_left(final RectConstraint r, final Object shrink) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
return r.getRect().shrink(_nv(shrink), 0, 0, 0); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _shrink_right(final RectConstraint r, final Object shrink) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
return r.getRect().shrink(0, 0, _nv(shrink), 0); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _grow(RectConstraint r, Object grow) |
||||
{ |
||||
final NumberConstraint n = _n(grow); |
||||
return _grow(r, n, n, n, n); |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _grow(RectConstraint r, Object horiz, Object vert) |
||||
{ |
||||
return _grow(r, horiz, vert, horiz, vert); |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _grow(final RectConstraint r, final Object xmin, final Object ymin, final Object xmax, final Object ymax) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
return r.getRect().grow(_nv(xmin), _nv(ymin), _nv(xmax), _nv(ymax)); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _grow_up(final RectConstraint r, final Object grow) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
return r.getRect().grow(0, _nv(grow), 0, 0); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _grow_down(final RectConstraint r, final Object grow) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
return r.getRect().grow(0, 0, 0, _nv(grow)); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _grow_left(final RectConstraint r, final Object grow) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
return r.getRect().grow(_nv(grow), 0, 0, 0); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _grow_right(final RectConstraint r, final Object grow) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
return r.getRect().grow(0, 0, _nv(grow), 0); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
/* ================= Box creation ================= */ |
||||
|
||||
public static RectConstraint _box(final Object side) |
||||
{ |
||||
return _box(side, side); |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _box(final Object width, final Object height) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
//@formatter:off
|
||||
return Rect.fromSize( |
||||
0, |
||||
0, |
||||
_nv(width), |
||||
_nv(height) |
||||
); |
||||
//@formatter:on
|
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _box(final RectConstraint r, final Object width, final Object height) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
final Coord origin = r.getRect().getOrigin(); |
||||
|
||||
//@formatter:off
|
||||
return Rect.fromSize( |
||||
origin.x(), |
||||
origin.y(), |
||||
_nv(width), |
||||
_nv(height) |
||||
); |
||||
//@formatter:on
|
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _box(final RectConstraint r, final Object x, final Object y, final Object width, final Object height) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
final Coord origin = r.getRect().getOrigin(); |
||||
|
||||
//@formatter:off
|
||||
return Rect.fromSize( |
||||
origin.x() + _nv(x), |
||||
origin.y() + _nv(y), |
||||
_nv(width), |
||||
_nv(height) |
||||
); |
||||
//@formatter:on
|
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _box_abs(final RectConstraint r, final Object xmin, final Object ymin, final Object xmax, final Object ymax) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
final Coord origin = r.getRect().getOrigin(); |
||||
|
||||
//@formatter:off
|
||||
return new Rect(origin.add(_nv(xmin), _nv(ymin)), origin.add(_nv(xmax), _nv(ymax))); |
||||
//@formatter:on
|
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _centered(final RectConstraint r, final RectConstraint centerTo) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
final Coord size = r.getRect().getSize(); |
||||
final Coord center = centerTo.getRect().getCenter(); |
||||
|
||||
return Rect.fromSize(center.x() - size.x() / 2D, center.y() - size.y() / 2D, size.x(), size.y()); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Center rect around given coords |
||||
* |
||||
* @param r rect |
||||
* @param x |
||||
* @param y |
||||
* @return centered |
||||
*/ |
||||
public static RectConstraint _centered(final RectConstraint r, final Object x, final Object y) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
final Coord size = r.getRect().getSize(); |
||||
|
||||
return Rect.fromSize(_nv(x) - size.x() / 2D, _nv(y) - size.y() / 2D, size.x(), size.y()); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _move(final RectConstraint r, final Object x, final Object y) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
return r.getRect().add(_nv(x), _nv(y)); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
/* ================= Rect bounds ================= */ |
||||
|
||||
/** |
||||
* Get zero-sized rect at the center |
||||
* |
||||
* @param r context |
||||
* @return center |
||||
*/ |
||||
public static RectConstraint _center(final RectConstraint r) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
return Rect.fromSize(r.getRect().getCenter(), 0, 0); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _left_edge(final RectConstraint r) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
return r.getRect().shrink(0, 0, r.getRect().getWidth(), 0); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _top_edge(final RectConstraint r) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
return r.getRect().shrink(0, 0, 0, r.getRect().getHeight()); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _right_edge(final RectConstraint r) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
return r.getRect().shrink(r.getRect().getWidth(), 0, 0, 0); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _bottom_edge(final RectConstraint r) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
return r.getRect().shrink(0, r.getRect().getHeight(), 0, 0); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _left_top(final RectConstraint r) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
return Rect.fromSize(r.getRect().getHMinVMin(), 0, 0); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _left_bottom(final RectConstraint r) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
return Rect.fromSize(r.getRect().getHMinVMax(), 0, 0); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _right_top(final RectConstraint r) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
return Rect.fromSize(r.getRect().getHMaxVMin(), 0, 0); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _right_bottom(final RectConstraint r) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
return Rect.fromSize(r.getRect().getHMaxVMax(), 0, 0); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _center_top(final RectConstraint r) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
return Rect.fromSize(r.getRect().getCenterVMin(), 0, 0); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _center_bottom(final RectConstraint r) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
return Rect.fromSize(r.getRect().getCenterVMax(), 0, 0); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _center_left(final RectConstraint r) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
return Rect.fromSize(r.getRect().getCenterHMin(), 0, 0); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
public static RectConstraint _center_right(final RectConstraint r) |
||||
{ |
||||
return new RectConstraint() { |
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
return Rect.fromSize(r.getRect().getCenterHMax(), 0, 0); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
|
||||
/* ================= Helpers ================= */ |
||||
|
||||
public static RectCache _cache(final RectConstraint rc) |
||||
{ |
||||
return new RectCache(rc); |
||||
} |
||||
|
||||
|
||||
public static RectCache _cache(final Poller poller, final RectConstraint rc) |
||||
{ |
||||
return new RectCache(poller, rc); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Convert {@link Number} to {@link NumberConstraint} if needed |
||||
* |
||||
* @param o unknown numeric value |
||||
* @return converted |
||||
*/ |
||||
public static NumberConstraint _n(final Object o) |
||||
{ |
||||
|
||||
if (o instanceof NumberConstraint) return (NumberConstraint) o; |
||||
|
||||
if (o instanceof Number) return new NumberConstraint() { |
||||
|
||||
@Override |
||||
public double getValue() |
||||
{ |
||||
return ((Number) o).doubleValue(); |
||||
} |
||||
}; |
||||
|
||||
throw new IllegalArgumentException("Invalid numeric type."); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Convert {@link Number} or {@link NumberConstraint} to double (current |
||||
* value) |
||||
* |
||||
* @param o unknown numeric value |
||||
* @return double value |
||||
*/ |
||||
public static double _nv(final Object o) |
||||
{ |
||||
return _n(o).getValue(); |
||||
} |
||||
|
||||
} |
||||
@ -1,16 +0,0 @@ |
||||
package mightypork.gamecore.gui.constraints; |
||||
|
||||
|
||||
/** |
||||
* Numeric constraint |
||||
* |
||||
* @author MightyPork |
||||
*/ |
||||
public interface NumberConstraint { |
||||
|
||||
/** |
||||
* @return current value |
||||
*/ |
||||
double getValue(); |
||||
|
||||
} |
||||
File diff suppressed because it is too large
Load Diff
@ -1,7 +1,7 @@ |
||||
package mightypork.gamecore.gui.constraints; |
||||
package mightypork.utils.math.constraints; |
||||
|
||||
|
||||
import mightypork.utils.math.coord.Rect; |
||||
import mightypork.utils.math.rect.Rect; |
||||
|
||||
|
||||
/** |
||||
@ -0,0 +1,34 @@ |
||||
package mightypork.utils.math.constraints; |
||||
|
||||
|
||||
/** |
||||
* Numeric constraint |
||||
* |
||||
* @author MightyPork |
||||
*/ |
||||
public interface NumberConstraint { |
||||
|
||||
public static final NumberConstraint ZERO = new NumberConstraint() { |
||||
|
||||
@Override |
||||
public double getValue() |
||||
{ |
||||
return 0; |
||||
} |
||||
}; |
||||
|
||||
public static final NumberConstraint ONE = new NumberConstraint() { |
||||
|
||||
@Override |
||||
public double getValue() |
||||
{ |
||||
return 0; |
||||
} |
||||
}; |
||||
|
||||
/** |
||||
* @return current value |
||||
*/ |
||||
double getValue(); |
||||
|
||||
} |
||||
@ -1,7 +1,7 @@ |
||||
package mightypork.gamecore.gui.constraints; |
||||
package mightypork.utils.math.constraints; |
||||
|
||||
|
||||
import mightypork.utils.math.coord.Rect; |
||||
import mightypork.utils.math.rect.Rect; |
||||
|
||||
|
||||
/** |
||||
@ -1,9 +1,9 @@ |
||||
package mightypork.gamecore.gui.constraints; |
||||
package mightypork.utils.math.constraints; |
||||
|
||||
|
||||
import mightypork.gamecore.control.timing.Pollable; |
||||
import mightypork.gamecore.control.timing.Poller; |
||||
import mightypork.utils.math.coord.Rect; |
||||
import mightypork.utils.math.rect.Rect; |
||||
|
||||
|
||||
/** |
||||
@ -1,7 +1,7 @@ |
||||
package mightypork.gamecore.gui.constraints; |
||||
package mightypork.utils.math.constraints; |
||||
|
||||
|
||||
import mightypork.utils.math.coord.Rect; |
||||
import mightypork.utils.math.rect.Rect; |
||||
|
||||
|
||||
/** |
||||
@ -0,0 +1,8 @@ |
||||
package mightypork.utils.math.constraints; |
||||
|
||||
import mightypork.utils.math.coord.VecView; |
||||
|
||||
|
||||
public interface VecConstraint { |
||||
VecView getVec(); |
||||
} |
||||
@ -0,0 +1,23 @@ |
||||
package mightypork.utils.math.constraints; |
||||
|
||||
|
||||
import mightypork.utils.math.coord.Vec; |
||||
import mightypork.utils.math.coord.VecView; |
||||
|
||||
|
||||
public class VecWrapper implements VecConstraint { |
||||
|
||||
private final Vec wrapped; |
||||
|
||||
|
||||
public VecWrapper(Vec wrapped) { |
||||
this.wrapped = wrapped; |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public VecView getVec() |
||||
{ |
||||
return wrapped.view(); |
||||
} |
||||
} |
||||
@ -0,0 +1,129 @@ |
||||
package mightypork.utils.math.coord; |
||||
|
||||
|
||||
import mightypork.gamecore.control.timing.Pauseable; |
||||
import mightypork.gamecore.control.timing.Updateable; |
||||
import mightypork.utils.math.animation.AnimDouble; |
||||
import mightypork.utils.math.animation.Easing; |
||||
|
||||
|
||||
/** |
||||
* 3D coordinated with support for transitions, mutable. |
||||
* |
||||
* @author MightyPork |
||||
*/ |
||||
public class AnimCoord extends VecMutableImpl<AnimCoord> implements Pauseable, Updateable { |
||||
|
||||
private final AnimDouble x, y, z; |
||||
|
||||
|
||||
public AnimCoord(AnimDouble x, AnimDouble y, AnimDouble z) { |
||||
this.x = x; |
||||
this.y = y; |
||||
this.z = z; |
||||
} |
||||
|
||||
|
||||
public AnimCoord(Vec start, Easing easing) { |
||||
x = new AnimDouble(start.x(), easing); |
||||
y = new AnimDouble(start.y(), easing); |
||||
z = new AnimDouble(start.z(), easing); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public double x() |
||||
{ |
||||
return x.now(); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public double y() |
||||
{ |
||||
return y.now(); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public double z() |
||||
{ |
||||
return z.now(); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public AnimCoord result(double x, double y, double z) |
||||
{ |
||||
this.x.setTo(x); |
||||
this.y.setTo(y); |
||||
this.z.setTo(z); |
||||
|
||||
return this; |
||||
} |
||||
|
||||
|
||||
public AnimCoord add(VecArith offset, double speed) |
||||
{ |
||||
animate(offset.add(this), speed); |
||||
return this; |
||||
} |
||||
|
||||
|
||||
public AnimCoord animate(Vec target, double duration) |
||||
{ |
||||
x.animate(target.x(), duration); |
||||
y.animate(target.y(), duration); |
||||
z.animate(target.z(), duration); |
||||
return this; |
||||
} |
||||
|
||||
|
||||
public void animateWithSpeed(Vec target, double unitsPerSecond) |
||||
{ |
||||
double dist = distTo(target); |
||||
double duration = dist / unitsPerSecond; |
||||
animate(target, duration); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public void update(double delta) |
||||
{ |
||||
x.update(delta); |
||||
y.update(delta); |
||||
z.update(delta); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public void pause() |
||||
{ |
||||
x.pause(); |
||||
y.pause(); |
||||
z.pause(); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public void resume() |
||||
{ |
||||
x.resume(); |
||||
y.resume(); |
||||
z.resume(); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public boolean isPaused() |
||||
{ |
||||
return x.isPaused(); // BUNO
|
||||
} |
||||
|
||||
|
||||
public boolean isFinished() |
||||
{ |
||||
return x.isFinished(); // BUNO
|
||||
} |
||||
|
||||
} |
||||
@ -0,0 +1,55 @@ |
||||
package mightypork.utils.math.coord; |
||||
|
||||
|
||||
import mightypork.utils.math.constraints.NumberConstraint; |
||||
|
||||
|
||||
/** |
||||
* Coord view composed of given {@link NumberConstraint}s, using their current |
||||
* values.<br> |
||||
* Operations yield a new {@link MutableCoord} with the result. |
||||
* |
||||
* @author MightyPork |
||||
*/ |
||||
public class ConstraintCoord extends VecView { |
||||
|
||||
private final NumberConstraint constrX; |
||||
private final NumberConstraint constrY; |
||||
private final NumberConstraint constrZ; |
||||
|
||||
|
||||
public ConstraintCoord(NumberConstraint x, NumberConstraint y, NumberConstraint z) { |
||||
this.constrX = x; |
||||
this.constrY = y; |
||||
this.constrZ = z; |
||||
} |
||||
|
||||
|
||||
public ConstraintCoord(NumberConstraint x, NumberConstraint y) { |
||||
this.constrX = x; |
||||
this.constrY = y; |
||||
this.constrZ = NumberConstraint.ZERO; |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public double x() |
||||
{ |
||||
return constrX.getValue(); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public double y() |
||||
{ |
||||
return constrY.getValue(); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public double z() |
||||
{ |
||||
return constrZ.getValue(); |
||||
} |
||||
|
||||
} |
||||
@ -1,42 +0,0 @@ |
||||
package mightypork.utils.math.coord; |
||||
|
||||
|
||||
import mightypork.gamecore.gui.constraints.NumberConstraint; |
||||
|
||||
|
||||
public class ConstraintCoordView extends CoordView { |
||||
|
||||
private final NumberConstraint xc; |
||||
private final NumberConstraint yc; |
||||
private final NumberConstraint zc; |
||||
|
||||
|
||||
public ConstraintCoordView(NumberConstraint x, NumberConstraint y, NumberConstraint z) { |
||||
super(null); |
||||
this.xc = x; |
||||
this.yc = y; |
||||
this.zc = z; |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public double x() |
||||
{ |
||||
return xc == null ? 0 : xc.getValue(); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public double y() |
||||
{ |
||||
return yc == null ? 0 : yc.getValue(); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public double z() |
||||
{ |
||||
return zc == null ? 0 : zc.getValue(); |
||||
} |
||||
|
||||
} |
||||
File diff suppressed because it is too large
Load Diff
@ -1,106 +0,0 @@ |
||||
package mightypork.utils.math.coord; |
||||
|
||||
|
||||
import mightypork.gamecore.control.timing.Updateable; |
||||
import mightypork.utils.math.Calc; |
||||
|
||||
|
||||
/** |
||||
* TODO revise |
||||
* |
||||
* @author MightyPork |
||||
*/ |
||||
public class CoordAnimated extends Coord implements Updateable { |
||||
|
||||
private double animTime = 0; |
||||
private Coord offs; |
||||
private Coord start; |
||||
private double time = 0; |
||||
|
||||
|
||||
/** |
||||
* Update delta timing |
||||
* |
||||
* @param delta delta time to add |
||||
*/ |
||||
@Override |
||||
public void update(double delta) |
||||
{ |
||||
if (start == null) start = new Coord(); |
||||
if (offs == null) offs = new Coord(); |
||||
animTime = Calc.clampd(animTime + delta, 0, time); |
||||
if (animIsFinished()) { |
||||
time = 0; |
||||
animTime = 0; |
||||
start.setTo(this); |
||||
} |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Remember position (other changes will be for animation) |
||||
*/ |
||||
public void animRemember() |
||||
{ |
||||
if (start == null) start = new Coord(); |
||||
if (offs == null) offs = new Coord(); |
||||
start.setTo(this); |
||||
offs = Coord.zero(); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Start animation |
||||
* |
||||
* @param time anim length |
||||
*/ |
||||
public void animStart(double time) |
||||
{ |
||||
if (start == null) start = new Coord(); |
||||
if (offs == null) offs = new Coord(); |
||||
this.time = time; |
||||
animTime = 0; |
||||
offs = start.vecTo(this); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Stop animation, assign to current value |
||||
*/ |
||||
public void animStop() |
||||
{ |
||||
setTo(animGetCurrent()); |
||||
animRemember(); |
||||
animTime = 0; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Get if animation is finished |
||||
* |
||||
* @return is finished |
||||
*/ |
||||
public boolean animIsFinished() |
||||
{ |
||||
return animTime >= time; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Get current value (animated) |
||||
* |
||||
* @return curent value |
||||
*/ |
||||
public Coord animGetCurrent() |
||||
{ |
||||
if (time == 0) return copy(); // avoid zero division
|
||||
|
||||
if (start == null) start = new Coord(); |
||||
if (offs == null) offs = new Coord(); |
||||
|
||||
if (animIsFinished()) return this; |
||||
|
||||
return start.add(offs.mul(animTime / time)); |
||||
} |
||||
|
||||
} |
||||
@ -0,0 +1,55 @@ |
||||
package mightypork.utils.math.coord; |
||||
|
||||
import mightypork.utils.math.constraints.VecConstraint; |
||||
|
||||
|
||||
/** |
||||
* <p><b>[ Use Vec.view() method to make a proxy! ]</b></p> |
||||
* <p>View of another coordinate, immutable.<br> |
||||
* Operations yield a new {@link MutableCoord} with the result.</p> |
||||
* |
||||
* @author MightyPork |
||||
*/ |
||||
public class CoordProxy extends VecView { |
||||
|
||||
private final Vec observed; |
||||
|
||||
|
||||
/** |
||||
* Protected, in order to enforce the use of view() method on Vec, which |
||||
* uses caching. |
||||
* |
||||
* @param observed |
||||
*/ |
||||
public CoordProxy(Vec observed) { |
||||
this.observed = observed; |
||||
} |
||||
|
||||
@Override |
||||
public CoordProxy view() |
||||
{ |
||||
return this; // no need to make another
|
||||
} |
||||
|
||||
|
||||
@Override |
||||
public double x() |
||||
{ |
||||
return observed.x(); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public double y() |
||||
{ |
||||
return observed.y(); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public double z() |
||||
{ |
||||
return observed.z(); |
||||
} |
||||
|
||||
} |
||||
@ -1,31 +1,54 @@ |
||||
package mightypork.utils.math.coord; |
||||
|
||||
|
||||
import mightypork.gamecore.gui.constraints.NumberConstraint; |
||||
|
||||
|
||||
/** |
||||
* Coord values provider |
||||
* Coordinate with immutable numeric values.<br> |
||||
* Operations yield a new {@link MutableCoord} with the result. |
||||
* |
||||
* @author MightyPork |
||||
*/ |
||||
public interface CoordValue { |
||||
public class CoordValue extends VecView { |
||||
|
||||
double x(); |
||||
private final double x, y, z; |
||||
|
||||
|
||||
double y(); |
||||
public CoordValue(Vec other) { |
||||
this(other.x(), other.y(), other.z()); |
||||
} |
||||
|
||||
|
||||
double z(); |
||||
public CoordValue(double x, double y) { |
||||
this(x, y, 0); |
||||
} |
||||
|
||||
|
||||
NumberConstraint xc(); |
||||
public CoordValue(double x, double y, double z) { |
||||
this.x = x; |
||||
this.y = y; |
||||
this.z = z; |
||||
} |
||||
|
||||
|
||||
NumberConstraint zc(); |
||||
@Override |
||||
public double x() |
||||
{ |
||||
return x; |
||||
} |
||||
|
||||
|
||||
NumberConstraint yc(); |
||||
@Override |
||||
public double y() |
||||
{ |
||||
return y; |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public double z() |
||||
{ |
||||
return z; |
||||
} |
||||
|
||||
} |
||||
|
||||
@ -1,62 +0,0 @@ |
||||
package mightypork.utils.math.coord; |
||||
|
||||
|
||||
public class CoordView extends Coord { |
||||
|
||||
private CoordValue observed = null; |
||||
|
||||
|
||||
public CoordView(CoordValue coord) { |
||||
observed = coord; |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public boolean isView() |
||||
{ |
||||
return true; |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public boolean isWritable() |
||||
{ |
||||
return false; |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public Coord view() |
||||
{ |
||||
return this; |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public Coord freeze() |
||||
{ |
||||
return this; // no effect
|
||||
} |
||||
|
||||
|
||||
@Override |
||||
public double x() |
||||
{ |
||||
return observed.x(); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public double y() |
||||
{ |
||||
return observed.y(); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public double z() |
||||
{ |
||||
return observed.z(); |
||||
} |
||||
|
||||
} |
||||
@ -0,0 +1,86 @@ |
||||
package mightypork.utils.math.coord; |
||||
|
||||
|
||||
/** |
||||
* Mutable coordinate.<br> |
||||
* All Vec methods (except copy) alter data values and return this instance. |
||||
* |
||||
* @author MightyPork |
||||
*/ |
||||
public class MutableCoord extends VecMutableImpl<MutableCoord> { |
||||
|
||||
private double x, y, z; |
||||
|
||||
|
||||
/** |
||||
* Zero coord |
||||
*/ |
||||
public MutableCoord() { |
||||
this(0, 0, 0); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* @param copied other coord to vopy |
||||
*/ |
||||
public MutableCoord(Vec copied) { |
||||
this(copied.x(), copied.y(), copied.z()); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* @param x X coordinate |
||||
* @param y Y coordinate |
||||
*/ |
||||
public MutableCoord(double x, double y) { |
||||
super(); |
||||
this.x = x; |
||||
this.y = y; |
||||
this.z = 0; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* @param x X coordinate |
||||
* @param y Y coordinate |
||||
* @param z Z coordinate |
||||
*/ |
||||
public MutableCoord(double x, double y, double z) { |
||||
super(); |
||||
this.x = x; |
||||
this.y = y; |
||||
this.z = z; |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public double x() |
||||
{ |
||||
return x; |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public double y() |
||||
{ |
||||
return y; |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public double z() |
||||
{ |
||||
return z; |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public MutableCoord result(double x, double y, double z) |
||||
{ |
||||
this.x = x; |
||||
this.y = y; |
||||
this.z = z; |
||||
|
||||
return this; |
||||
} |
||||
} |
||||
@ -1,868 +0,0 @@ |
||||
package mightypork.utils.math.coord; |
||||
|
||||
|
||||
import mightypork.gamecore.gui.constraints.NumberConstraint; |
||||
import mightypork.gamecore.gui.constraints.RectConstraint; |
||||
import mightypork.utils.math.Calc; |
||||
|
||||
|
||||
/** |
||||
* Rectangle determined by two coordinates - min and max. |
||||
* |
||||
* @author MightyPork |
||||
*/ |
||||
public class Rect implements RectConstraint { |
||||
|
||||
public static final Rect ZERO = new Rect(0, 0, 0, 0).freeze(); |
||||
public static final Rect ONE = new Rect(0, 0, 1, 1).freeze(); |
||||
|
||||
|
||||
/** |
||||
* Rectangle from size; coords are copied. |
||||
* |
||||
* @param min min coord |
||||
* @param size rect size |
||||
* @return the rect |
||||
*/ |
||||
public static Rect fromSize(Coord min, Coord size) |
||||
{ |
||||
return fromSize(min, size.xi(), size.yi()); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Make rect from min coord and size; coords are copied. |
||||
* |
||||
* @param min min coord |
||||
* @param width size x |
||||
* @param height size y |
||||
* @return the new rect |
||||
*/ |
||||
public static Rect fromSize(Coord min, double width, double height) |
||||
{ |
||||
return new Rect(min.copy(), min.add(width, height)); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Rectangle from size |
||||
* |
||||
* @param sizeX size x |
||||
* @param sizeY size y |
||||
* @return rect |
||||
*/ |
||||
public static Rect fromSize(double sizeX, double sizeY) |
||||
{ |
||||
return fromSize(0, 0, sizeX, sizeY); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Get rect from size |
||||
* |
||||
* @param size size |
||||
* @return rect |
||||
*/ |
||||
public static Rect fromSize(Coord size) |
||||
{ |
||||
return fromSize(0, 0, size.x(), size.y()); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Make rect from min coord and size |
||||
* |
||||
* @param xmin min x |
||||
* @param ymin min y |
||||
* @param width size x |
||||
* @param height size y |
||||
* @return the new rect |
||||
*/ |
||||
public static Rect fromSize(double xmin, double ymin, double width, double height) |
||||
{ |
||||
return new Rect(xmin, ymin, xmin + width, ymin + height); |
||||
} |
||||
|
||||
/** Lowest coordinates xy */ |
||||
protected final Coord min; |
||||
|
||||
/** Highest coordinates xy */ |
||||
protected final Coord max; |
||||
|
||||
// view of secondary corners.
|
||||
|
||||
//@formatter:off
|
||||
private final ConstraintCoordView HMinVMax = new ConstraintCoordView( |
||||
new NumberConstraint() { |
||||
@Override |
||||
public double getValue() |
||||
{ |
||||
return min.x(); |
||||
} |
||||
}, |
||||
new NumberConstraint() { |
||||
@Override |
||||
public double getValue() |
||||
{ |
||||
return max.y(); |
||||
} |
||||
}, |
||||
null |
||||
); |
||||
|
||||
|
||||
private final ConstraintCoordView HMaxVMin = new ConstraintCoordView( |
||||
new NumberConstraint() { |
||||
@Override |
||||
public double getValue() { |
||||
return max.x(); |
||||
} |
||||
}, |
||||
new NumberConstraint() { |
||||
@Override |
||||
public double getValue() |
||||
{ |
||||
return min.y(); |
||||
} |
||||
}, |
||||
null |
||||
); |
||||
//@formatter:on
|
||||
|
||||
private boolean frozen; |
||||
|
||||
|
||||
public boolean isWritable() |
||||
{ |
||||
return !frozen && !isView(); |
||||
} |
||||
|
||||
|
||||
public boolean isView() |
||||
{ |
||||
return false; |
||||
} |
||||
|
||||
|
||||
public Rect freeze() |
||||
{ |
||||
min.freeze(); |
||||
max.freeze(); |
||||
frozen = true; |
||||
return this; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Get a readonly view |
||||
* |
||||
* @return view |
||||
*/ |
||||
public RectView view() |
||||
{ |
||||
return new RectView(this); |
||||
} |
||||
|
||||
|
||||
protected void assertWritable() |
||||
{ |
||||
if (!isWritable()) { |
||||
throw new UnsupportedOperationException("This Rect is not writable."); |
||||
} |
||||
} |
||||
|
||||
|
||||
/** |
||||
* New Rect [0, 0, 0, 0] |
||||
*/ |
||||
public Rect() { |
||||
this(0, 0, 0, 0); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Rect [0, 0, size.x, size.y] |
||||
* |
||||
* @param size size coord |
||||
*/ |
||||
public Rect(Coord size) { |
||||
this(0, 0, size.x(), size.y()); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* New rect of two coords; Coords are plugged in directly (ie. views can be |
||||
* used for frozen rect representing another) |
||||
* |
||||
* @param min coord 1 |
||||
* @param max coord 2 |
||||
*/ |
||||
public Rect(Coord min, Coord max) { |
||||
this.min = min; // must not copy
|
||||
this.max = max; // must not copy
|
||||
} |
||||
|
||||
|
||||
/** |
||||
* New Rect |
||||
* |
||||
* @param xmin lower x |
||||
* @param ymin lower y |
||||
* @param xmax upper x |
||||
* @param ymax upper y |
||||
*/ |
||||
public Rect(double xmin, double ymin, double xmax, double ymax) { |
||||
min = new Coord(xmin, ymin); |
||||
max = new Coord(xmax, ymax); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Rect [0, 0, x, y] |
||||
* |
||||
* @param x width |
||||
* @param y height |
||||
*/ |
||||
public Rect(double x, double y) { |
||||
this(0, 0, x, y); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* New rect as a copy of other rect |
||||
* |
||||
* @param r other rect |
||||
*/ |
||||
public Rect(Rect r) { |
||||
this(r.min.copy(), r.max.copy()); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Get offset copy (add) |
||||
* |
||||
* @param move offset vector |
||||
* @return offset copy |
||||
*/ |
||||
public Rect add(Coord move) |
||||
{ |
||||
return copy().add_ip(move); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Add X and Y to all coordinates in a copy |
||||
* |
||||
* @param x x to add |
||||
* @param y y to add |
||||
* @return copy changed |
||||
*/ |
||||
public Rect add(double x, double y) |
||||
{ |
||||
return add(new Coord(x, y)); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Offset in place (add) |
||||
* |
||||
* @param move offset vector |
||||
* @return this |
||||
*/ |
||||
public Rect add_ip(Coord move) |
||||
{ |
||||
min.add_ip(move); |
||||
max.add_ip(move); |
||||
return this; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Add X and Y to all coordinates in place |
||||
* |
||||
* @param x x to add |
||||
* @param y y to add |
||||
* @return this |
||||
*/ |
||||
public Rect add_ip(double x, double y) |
||||
{ |
||||
return add_ip(new Coord(x, y)); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Get a copy |
||||
* |
||||
* @return copy |
||||
*/ |
||||
public Rect copy() |
||||
{ |
||||
return new Rect(this); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Get rect center |
||||
* |
||||
* @return center |
||||
*/ |
||||
public Coord getCenter() |
||||
{ |
||||
return min.midTo(max).freeze(); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Get center of the lower edge. |
||||
* |
||||
* @return center |
||||
*/ |
||||
public Coord getCenterVMin() |
||||
{ |
||||
return new Coord((max.x() + min.x()) / 2D, min.y()).freeze(); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Get center of the left edge. |
||||
* |
||||
* @return center |
||||
*/ |
||||
public Coord getCenterHMin() |
||||
{ |
||||
return new Coord(min.x(), (max.y() + min.y()) / 2D).freeze(); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Get center of the right edge. |
||||
* |
||||
* @return center |
||||
*/ |
||||
public Coord getCenterHMax() |
||||
{ |
||||
return new Coord(max.x(), (max.y() + min.y()) / 2D).freeze(); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Get center of the top edge. |
||||
* |
||||
* @return center |
||||
*/ |
||||
public Coord getCenterVMax() |
||||
{ |
||||
return new Coord((max.x() + min.x()) / 2D, max.y()).freeze(); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Get left bottom |
||||
* |
||||
* @return center |
||||
*/ |
||||
public Coord getHMinVMin() |
||||
{ |
||||
return min.view(); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Get left top |
||||
* |
||||
* @return center |
||||
*/ |
||||
public Coord getHMinVMax() |
||||
{ |
||||
return HMinVMax; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Get right bottom |
||||
* |
||||
* @return center |
||||
*/ |
||||
public Coord getHMaxVMin() |
||||
{ |
||||
return HMaxVMin; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Get right top |
||||
* |
||||
* @return center |
||||
*/ |
||||
public Coord getHMaxVMax() |
||||
{ |
||||
return max.view(); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Alias for getX2Y2 |
||||
* |
||||
* @return highest coordinates xy |
||||
*/ |
||||
public Coord getMax() |
||||
{ |
||||
return getHMaxVMax(); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Alias for getX1Y1 |
||||
* |
||||
* @return lowest coordinates xy |
||||
*/ |
||||
public Coord getMin() |
||||
{ |
||||
return getHMinVMin(); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Alias for getX1Y1 |
||||
* |
||||
* @return lowest coordinates xy |
||||
*/ |
||||
public Coord getOrigin() |
||||
{ |
||||
return getHMinVMin(); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Shrink to sides in copy |
||||
* |
||||
* @param shrink shrink size (added to each side) |
||||
* @return shrinkn copy |
||||
*/ |
||||
public Rect shrink(Coord shrink) |
||||
{ |
||||
return copy().shrink_ip(shrink); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Shrink to sides in copy |
||||
* |
||||
* @param x x to add |
||||
* @param y y to add |
||||
* @return changed copy |
||||
*/ |
||||
public Rect shrink(double x, double y) |
||||
{ |
||||
return copy().shrink_ip(x, y); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Shrink to sides in place |
||||
* |
||||
* @param shrink shrink size (added to each side) |
||||
* @return this |
||||
*/ |
||||
public Rect shrink_ip(Coord shrink) |
||||
{ |
||||
shrink_ip(shrink.x(), shrink.y()); |
||||
return this; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Shrink to sides in place |
||||
* |
||||
* @param x horizontal shrink |
||||
* @param y vertical shrink |
||||
* @return this |
||||
*/ |
||||
public Rect shrink_ip(double x, double y) |
||||
{ |
||||
min.sub_ip(x, y); |
||||
max.add_ip(-x, -y); |
||||
return this; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Shrink the rect |
||||
* |
||||
* @param xmin shrink |
||||
* @param ymin shrink |
||||
* @param xmax shrink |
||||
* @param ymax shrink |
||||
* @return changed copy |
||||
*/ |
||||
public Rect shrink(double xmin, double ymin, double xmax, double ymax) |
||||
{ |
||||
return copy().shrink_ip(xmin, ymin, xmax, ymax); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Shrink the rect in place |
||||
* |
||||
* @param xmin shrink |
||||
* @param ymin shrink |
||||
* @param xmax shrink |
||||
* @param ymax shrink |
||||
* @return this |
||||
*/ |
||||
public Rect shrink_ip(double xmin, double ymin, double xmax, double ymax) |
||||
{ |
||||
min.add_ip(xmin, ymin); |
||||
max.add_ip(-xmax, -ymax); |
||||
return this; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Grow to sides in copy |
||||
* |
||||
* @param grow grow size (added to each side) |
||||
* @return grown copy |
||||
*/ |
||||
public Rect grow(Coord grow) |
||||
{ |
||||
return copy().grow_ip(grow); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Grow to sides in copy |
||||
* |
||||
* @param x horizontal grow |
||||
* @param y vertical grow |
||||
* @return changed copy |
||||
*/ |
||||
public Rect grow(double x, double y) |
||||
{ |
||||
return copy().grow_ip(x, y); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Grow to sides in place |
||||
* |
||||
* @param grow grow size (added to each side) |
||||
* @return this |
||||
*/ |
||||
public Rect grow_ip(Coord grow) |
||||
{ |
||||
grow_ip(grow.x(), grow.y()); |
||||
return this; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Grow to sides in place |
||||
* |
||||
* @param x horizontal grow |
||||
* @param y vertical grow |
||||
* @return this |
||||
*/ |
||||
public Rect grow_ip(double x, double y) |
||||
{ |
||||
min.sub_ip(x, y); |
||||
max.add_ip(x, y); |
||||
return this; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Grow the rect |
||||
* |
||||
* @param xmin growth |
||||
* @param ymin growth |
||||
* @param xmax growth |
||||
* @param ymax growth |
||||
* @return changed copy |
||||
*/ |
||||
public Rect grow(double xmin, double ymin, double xmax, double ymax) |
||||
{ |
||||
return copy().grow_ip(xmin, ymin, xmax, ymax); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Grow the rect in place |
||||
* |
||||
* @param xmin growth |
||||
* @param ymin growth |
||||
* @param xmax growth |
||||
* @param ymax growth |
||||
* @return this |
||||
*/ |
||||
public Rect grow_ip(double xmin, double ymin, double xmax, double ymax) |
||||
{ |
||||
min.add_ip(-xmin, -ymin); |
||||
max.add_ip(xmax, ymax); |
||||
return this; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Check if point is inside this rectangle |
||||
* |
||||
* @param point point to test |
||||
* @return is inside |
||||
*/ |
||||
public boolean isInside(Coord point) |
||||
{ |
||||
return Calc.inRange(point.x(), min.x(), max.x()) && Calc.inRange(point.y(), min.y(), max.y()); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Multiply in copy |
||||
* |
||||
* @param factor multiplier |
||||
* @return offset copy |
||||
*/ |
||||
public Rect mul(double factor) |
||||
{ |
||||
return copy().mul_ip(factor); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Multiply by number (useful for centered rects) |
||||
* |
||||
* @param x x multiplier |
||||
* @param y y multiplier |
||||
* @return copy multiplied |
||||
*/ |
||||
public Rect mul(double x, double y) |
||||
{ |
||||
return copy().mul_ip(x, y); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Multiply coord in place |
||||
* |
||||
* @param factor multiplier |
||||
* @return this |
||||
*/ |
||||
public Rect mul_ip(double factor) |
||||
{ |
||||
min.mul_ip(factor); |
||||
max.mul_ip(factor); |
||||
return this; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Multiply coord in place |
||||
* |
||||
* @param x multiplier x |
||||
* @param y multiplier y |
||||
* @return this |
||||
*/ |
||||
public Rect mul_ip(double x, double y) |
||||
{ |
||||
min.mul_ip(x, y, 1); |
||||
max.mul_ip(x, y, 1); |
||||
return this; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Round coords in copy |
||||
* |
||||
* @return copy, rounded |
||||
*/ |
||||
public Rect round() |
||||
{ |
||||
return new Rect(min.round(), max.round()); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Round this in place |
||||
* |
||||
* @return this |
||||
*/ |
||||
public Rect round_ip() |
||||
{ |
||||
min.round_ip(); |
||||
max.round_ip(); |
||||
return this; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Set to coordinates |
||||
* |
||||
* @param xmin lower x |
||||
* @param ymin lower y |
||||
* @param xmax upper x |
||||
* @param ymax upper y |
||||
*/ |
||||
public void setTo(double xmin, double ymin, double xmax, double ymax) |
||||
{ |
||||
min.setTo(Math.min(xmin, xmax), Math.min(ymin, ymax)); |
||||
max.setTo(Math.max(xmin, xmax), Math.max(ymin, ymax)); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Set to other rect's coordinates |
||||
* |
||||
* @param r other rect |
||||
*/ |
||||
public void setTo(Rect r) |
||||
{ |
||||
min.setTo(r.min); |
||||
max.setTo(r.max); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Subtract X and Y from all coordinates in a copy |
||||
* |
||||
* @param x x to subtract |
||||
* @param y y to subtract |
||||
* @return copy changed |
||||
*/ |
||||
public Rect sub(double x, double y) |
||||
{ |
||||
return sub(new Coord(x, y)); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Get offset copy (subtract) |
||||
* |
||||
* @param move offset vector |
||||
* @return offset copy |
||||
*/ |
||||
public Rect sub(Coord move) |
||||
{ |
||||
return copy().sub_ip(move); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Subtract X and Y from all coordinates in place |
||||
* |
||||
* @param x x to subtract |
||||
* @param y y to subtract |
||||
* @return this |
||||
*/ |
||||
public Rect sub_ip(double x, double y) |
||||
{ |
||||
return sub_ip(new Coord(x, y)); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Offset in place (subtract) |
||||
* |
||||
* @param move offset vector |
||||
* @return this |
||||
*/ |
||||
public Rect sub_ip(Coord move) |
||||
{ |
||||
min.sub_ip(move); |
||||
max.sub_ip(move); |
||||
return this; |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public String toString() |
||||
{ |
||||
return String.format("[%s-%s]", min.toString(), max.toString()); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* @return lower x |
||||
*/ |
||||
public double xMin() |
||||
{ |
||||
return min.x(); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* @return upper x |
||||
*/ |
||||
public double xMax() |
||||
{ |
||||
return max.x(); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* @return lower y |
||||
*/ |
||||
public double yMin() |
||||
{ |
||||
return min.y(); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* @return upper y |
||||
*/ |
||||
public double yMax() |
||||
{ |
||||
return max.y(); |
||||
} |
||||
|
||||
|
||||
public double getHeight() |
||||
{ |
||||
return max.y() - min.y(); |
||||
} |
||||
|
||||
|
||||
public double getWidth() |
||||
{ |
||||
return max.x() - min.x(); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Get size (width, height) as (x,y) |
||||
* |
||||
* @return coord of width,height |
||||
*/ |
||||
public Coord getSize() |
||||
{ |
||||
return new Coord(max.x() - min.x(), max.y() - min.y()); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public Rect getRect() |
||||
{ |
||||
return this; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Generate zero rect |
||||
* |
||||
* @return zero |
||||
*/ |
||||
public static Rect zero() |
||||
{ |
||||
return ZERO.copy(); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Generate 0,0-1,1 rect |
||||
* |
||||
* @return one |
||||
*/ |
||||
public static Rect one() |
||||
{ |
||||
return ZERO.copy(); |
||||
} |
||||
} |
||||
@ -1,37 +0,0 @@ |
||||
package mightypork.utils.math.coord; |
||||
|
||||
|
||||
/** |
||||
* Read only rect |
||||
* |
||||
* @author MightyPork |
||||
*/ |
||||
public class RectView extends Rect { |
||||
|
||||
public RectView(Rect observed) { |
||||
super(observed.min.view(), observed.max.view()); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public boolean isWritable() |
||||
{ |
||||
return false; |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public boolean isView() |
||||
{ |
||||
return true; |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public Rect freeze() |
||||
{ |
||||
// do nothing
|
||||
return this; |
||||
} |
||||
|
||||
} |
||||
@ -0,0 +1,25 @@ |
||||
package mightypork.utils.math.coord; |
||||
|
||||
import mightypork.utils.math.constraints.NumberConstraint; |
||||
|
||||
|
||||
/** |
||||
* 2D coord for anonymous implementations.<br> |
||||
* Operations yield a new {@link MutableCoord} with the result. |
||||
* |
||||
* @author MightyPork |
||||
*/ |
||||
public abstract class SynthCoord2D extends VecView { |
||||
|
||||
@Override |
||||
public abstract double x(); |
||||
|
||||
@Override |
||||
public abstract double y(); |
||||
|
||||
@Override |
||||
public double z() |
||||
{ |
||||
return 0; |
||||
} |
||||
} |
||||
@ -0,0 +1,26 @@ |
||||
package mightypork.utils.math.coord; |
||||
|
||||
|
||||
import mightypork.utils.math.constraints.NumberConstraint; |
||||
|
||||
|
||||
/** |
||||
* 3D immutable coord for anonymous implementations.<br> |
||||
* Operations yield a new {@link MutableCoord} with the result. |
||||
* |
||||
* @author MightyPork |
||||
*/ |
||||
public abstract class SynthCoord3D extends VecView { |
||||
|
||||
@Override |
||||
public abstract double x(); |
||||
|
||||
|
||||
@Override |
||||
public abstract double y(); |
||||
|
||||
|
||||
@Override |
||||
public abstract double z(); |
||||
|
||||
} |
||||
@ -0,0 +1,101 @@ |
||||
package mightypork.utils.math.coord; |
||||
|
||||
|
||||
import mightypork.utils.math.constraints.NumberConstraint; |
||||
|
||||
|
||||
public interface Vec { |
||||
|
||||
public static final VecView ZERO = new CoordValue(0, 0, 0); |
||||
public static final VecView ONE = new CoordValue(1, 1, 1); |
||||
|
||||
|
||||
/** |
||||
* @return X coordinate |
||||
*/ |
||||
double x(); |
||||
|
||||
|
||||
/** |
||||
* @return Y coordinate |
||||
*/ |
||||
double y(); |
||||
|
||||
|
||||
/** |
||||
* @return Z coordinate |
||||
*/ |
||||
double z(); |
||||
|
||||
|
||||
/** |
||||
* @return X rounded |
||||
*/ |
||||
int xi(); |
||||
|
||||
|
||||
/** |
||||
* @return Y rounded |
||||
*/ |
||||
int yi(); |
||||
|
||||
|
||||
/** |
||||
* @return Z rounded |
||||
*/ |
||||
int zi(); |
||||
|
||||
|
||||
/** |
||||
* @return X as float |
||||
*/ |
||||
float xf(); |
||||
|
||||
|
||||
/** |
||||
* @return Y as float |
||||
*/ |
||||
float yf(); |
||||
|
||||
|
||||
/** |
||||
* @return Z as float |
||||
*/ |
||||
float zf(); |
||||
|
||||
|
||||
/** |
||||
* @return X constraint |
||||
*/ |
||||
NumberConstraint xc(); |
||||
|
||||
|
||||
/** |
||||
* @return Y constraint |
||||
*/ |
||||
NumberConstraint yc(); |
||||
|
||||
|
||||
/** |
||||
* @return Z constraint |
||||
*/ |
||||
NumberConstraint zc(); |
||||
|
||||
|
||||
/** |
||||
* Get a new mutable variable holding the current state |
||||
* |
||||
* @return a mutable copy |
||||
*/ |
||||
MutableCoord copy(); |
||||
|
||||
|
||||
/** |
||||
* Get immutable view at this vec |
||||
* |
||||
* @return immutable view |
||||
*/ |
||||
CoordProxy view(); |
||||
|
||||
|
||||
} |
||||
@ -0,0 +1,248 @@ |
||||
package mightypork.utils.math.coord; |
||||
|
||||
import mightypork.utils.math.constraints.VecConstraint; |
||||
|
||||
|
||||
/** |
||||
* 3D coordinate methods |
||||
* |
||||
* @author MightyPork |
||||
*/ |
||||
interface VecArith extends Vec { |
||||
|
||||
/** |
||||
* Set X coordinate (if immutable, in a copy). |
||||
* |
||||
* @param x x coordinate |
||||
* @return result |
||||
*/ |
||||
Vec setX(double x); |
||||
|
||||
|
||||
/** |
||||
* Set Y coordinate (if immutable, in a copy). |
||||
* |
||||
* @param y y coordinate |
||||
* @return result |
||||
*/ |
||||
Vec setY(double y); |
||||
|
||||
|
||||
/** |
||||
* Set Z coordinate (if immutable, in a copy). |
||||
* |
||||
* @param z z coordinate |
||||
* @return result |
||||
*/ |
||||
Vec setZ(double z); |
||||
|
||||
|
||||
/** |
||||
* Get distance to other point |
||||
* |
||||
* @param point other point |
||||
* @return distance |
||||
*/ |
||||
double distTo(Vec point); |
||||
|
||||
|
||||
/** |
||||
* Get dot product (scalar multiplication) |
||||
* |
||||
* @param vec other vector |
||||
* @return dot product |
||||
*/ |
||||
double dot(Vec vec); |
||||
|
||||
|
||||
/** |
||||
* Get vector size |
||||
* |
||||
* @return size |
||||
*/ |
||||
double size(); |
||||
|
||||
|
||||
/** |
||||
* @return true if zero |
||||
*/ |
||||
boolean isZero(); |
||||
|
||||
/** |
||||
* Create vector from this point to other point |
||||
* |
||||
* @param point second point |
||||
* @return result |
||||
*/ |
||||
Vec vecTo(Vec point); |
||||
|
||||
|
||||
/** |
||||
* Get middle of line to other point |
||||
* |
||||
* @param point other point |
||||
* @return result |
||||
*/ |
||||
Vec midTo(Vec point); |
||||
|
||||
|
||||
/** |
||||
* Add a vector. |
||||
* |
||||
* @param vec offset |
||||
* @return result |
||||
*/ |
||||
Vec add(Vec vec); |
||||
|
||||
|
||||
/** |
||||
* Add to each component.<br> |
||||
* Z is unchanged. |
||||
* |
||||
* @param x x offset |
||||
* @param y y offset |
||||
* @return result |
||||
*/ |
||||
Vec add(double x, double y); |
||||
|
||||
|
||||
/** |
||||
* Add to each component. |
||||
* |
||||
* @param x x offset |
||||
* @param y y offset |
||||
* @param z z offset |
||||
* @return result |
||||
*/ |
||||
Vec add(double x, double y, double z); |
||||
|
||||
|
||||
/** |
||||
* Get copy divided by two |
||||
* |
||||
* @return result |
||||
*/ |
||||
Vec half(); |
||||
|
||||
|
||||
/** |
||||
* Multiply each component. |
||||
* |
||||
* @param d multiplier |
||||
* @return result |
||||
*/ |
||||
Vec mul(double d); |
||||
|
||||
|
||||
/** |
||||
* Multiply each component. |
||||
* |
||||
* @param vec vector of multipliers |
||||
* @return result |
||||
*/ |
||||
Vec mul(Vec vec); |
||||
|
||||
|
||||
/** |
||||
* Multiply each component.<br> |
||||
* Z is unchanged. |
||||
* |
||||
* @param x x multiplier |
||||
* @param y y multiplier |
||||
* @return result |
||||
*/ |
||||
Vec mul(double x, double y); |
||||
|
||||
|
||||
/** |
||||
* Multiply each component. |
||||
* |
||||
* @param x x multiplier |
||||
* @param y y multiplier |
||||
* @param z z multiplier |
||||
* @return result |
||||
*/ |
||||
Vec mul(double x, double y, double z); |
||||
|
||||
|
||||
/** |
||||
* Round coordinates. |
||||
* |
||||
* @return result |
||||
*/ |
||||
Vec round(); |
||||
|
||||
|
||||
/** |
||||
* Round coordinates down. |
||||
* |
||||
* @return result |
||||
*/ |
||||
Vec floor(); |
||||
|
||||
|
||||
/** |
||||
* Round coordinates up. |
||||
* |
||||
* @return result |
||||
*/ |
||||
Vec ceil(); |
||||
|
||||
|
||||
/** |
||||
* Subtract vector. |
||||
* |
||||
* @param vec offset |
||||
* @return result |
||||
*/ |
||||
Vec sub(Vec vec); |
||||
|
||||
|
||||
/** |
||||
* Subtract a 2D vector.<br> |
||||
* Z is unchanged. |
||||
* |
||||
* @param x x offset |
||||
* @param y y offset |
||||
* @return result |
||||
*/ |
||||
VecArith sub(double x, double y); |
||||
|
||||
|
||||
/** |
||||
* Subtract a 3D vector. |
||||
* |
||||
* @param x x offset |
||||
* @param y y offset |
||||
* @param z z offset |
||||
* @return result |
||||
*/ |
||||
Vec sub(double x, double y, double z); |
||||
|
||||
|
||||
/** |
||||
* Negate all coordinates (* -1) |
||||
* |
||||
* @return result |
||||
*/ |
||||
Vec neg(); |
||||
|
||||
|
||||
/** |
||||
* Scale vector to given size. |
||||
* |
||||
* @param size size we need |
||||
* @return result |
||||
*/ |
||||
Vec norm(double size); |
||||
|
||||
|
||||
/** |
||||
* Get cross product (vector multiplication) |
||||
* |
||||
* @param vec other vector |
||||
* @return result |
||||
*/ |
||||
public Vec cross(Vec vec); |
||||
|
||||
} |
||||
@ -0,0 +1,383 @@ |
||||
package mightypork.utils.math.coord; |
||||
|
||||
|
||||
import mightypork.utils.math.constraints.NumberConstraint; |
||||
|
||||
|
||||
/** |
||||
* Implementation of coordinate methods |
||||
* |
||||
* @author MightyPork |
||||
* @param <V> Return type of methods |
||||
*/ |
||||
abstract class VecImpl<V extends VecArith> implements VecArith { |
||||
|
||||
private NumberConstraint constraintZ, constraintY, constraintX; |
||||
|
||||
private CoordProxy view = null; |
||||
|
||||
|
||||
@Override |
||||
public abstract double x(); |
||||
|
||||
|
||||
@Override |
||||
public abstract double y(); |
||||
|
||||
|
||||
@Override |
||||
public abstract double z(); |
||||
|
||||
|
||||
@Override |
||||
public int xi() |
||||
{ |
||||
return (int) Math.round(x()); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public int yi() |
||||
{ |
||||
return (int) Math.round(y()); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public int zi() |
||||
{ |
||||
return (int) Math.round(z()); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public float xf() |
||||
{ |
||||
return (float) x(); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public float yf() |
||||
{ |
||||
return (float) y(); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public float zf() |
||||
{ |
||||
return (float) z(); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* <p> |
||||
* Some operation was performed and this result was obtained. |
||||
* </p> |
||||
* <p> |
||||
* It's now up to implementing class what to do - mutable ones can alter |
||||
* it's data values, immutable can return a new Vec. |
||||
* </p> |
||||
* |
||||
* @param x |
||||
* @param y |
||||
* @param z |
||||
* @return the result Vec |
||||
*/ |
||||
public abstract V result(double x, double y, double z); |
||||
|
||||
|
||||
@Override |
||||
public MutableCoord copy() |
||||
{ |
||||
return new MutableCoord(this); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public CoordProxy view() |
||||
{ |
||||
if (view == null) view = new CoordProxy(this); |
||||
|
||||
return view; |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public NumberConstraint xc() |
||||
{ |
||||
if (constraintX == null) constraintX = new NumberConstraint() { |
||||
|
||||
@Override |
||||
public double getValue() |
||||
{ |
||||
return x(); |
||||
} |
||||
}; |
||||
|
||||
return constraintX; |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public NumberConstraint yc() |
||||
{ |
||||
if (constraintY == null) constraintY = new NumberConstraint() { |
||||
|
||||
@Override |
||||
public double getValue() |
||||
{ |
||||
return y(); |
||||
} |
||||
}; |
||||
|
||||
return constraintY; |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public NumberConstraint zc() |
||||
{ |
||||
if (constraintZ == null) constraintZ = new NumberConstraint() { |
||||
|
||||
@Override |
||||
public double getValue() |
||||
{ |
||||
return z(); |
||||
} |
||||
}; |
||||
|
||||
return constraintZ; |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public V setX(double x) |
||||
{ |
||||
return result(x, y(), z()); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public V setY(double y) |
||||
{ |
||||
return result(x(), y, z()); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public V setZ(double z) |
||||
{ |
||||
return result(x(), y(), z); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public double size() |
||||
{ |
||||
double x = x(), y = y(), z = z(); |
||||
return Math.sqrt(x * x + y * y + z * z); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public boolean isZero() |
||||
{ |
||||
return x() == 0 && y() == 0 && z() == 0; |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public V add(Vec vec) |
||||
{ |
||||
return add(vec.x(), vec.y(), vec.z()); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public V add(double x, double y) |
||||
{ |
||||
return add(x, y, 0); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public V add(double x, double y, double z) |
||||
{ |
||||
return result(x, y, z); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public double distTo(Vec point) |
||||
{ |
||||
double dx = x() - point.x(); |
||||
double dy = y() - point.y(); |
||||
double dz = z() - point.z(); |
||||
|
||||
return Math.sqrt(dx * dx + dy * dy + dz * dz); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public V midTo(Vec point) |
||||
{ |
||||
double dx = (point.x() - x()) * 0.5; |
||||
double dy = (point.y() - y()) * 0.5; |
||||
double dz = (point.z() - z()) * 0.5; |
||||
|
||||
return result(dx, dy, dz); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public V half() |
||||
{ |
||||
return mul(0.5); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public V mul(double d) |
||||
{ |
||||
return mul(d, d, d); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public V mul(Vec vec) |
||||
{ |
||||
return mul(vec.x(), vec.y(), vec.z()); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public V mul(double x, double y) |
||||
{ |
||||
return mul(x, y, 1); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public V mul(double x, double y, double z) |
||||
{ |
||||
return result(x() * x, y() * y, z() * z); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public V round() |
||||
{ |
||||
return result(Math.round(x()), Math.round(y()), Math.round(z())); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public V floor() |
||||
{ |
||||
return result(Math.floor(x()), Math.floor(y()), Math.floor(z())); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public V ceil() |
||||
{ |
||||
return result(Math.ceil(x()), Math.ceil(y()), Math.ceil(z())); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public V sub(Vec vec) |
||||
{ |
||||
return sub(vec.x(), vec.y(), vec.z()); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public V sub(double x, double y) |
||||
{ |
||||
return sub(x, y, 0); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public V sub(double x, double y, double z) |
||||
{ |
||||
return result(x() - x, y() - y, z() - z); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public V vecTo(Vec point) |
||||
{ |
||||
return result(point.x() - x(), point.y() - y(), point.z() - z()); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public V cross(Vec vec) |
||||
{ |
||||
//@formatter:off
|
||||
return result( |
||||
y() * vec.z() - z() * vec.y(), |
||||
z() * vec.x() - x() * vec.z(), |
||||
x() * vec.y() - y() * vec.x()); |
||||
//@formatter:on
|
||||
} |
||||
|
||||
|
||||
@Override |
||||
public double dot(Vec vec) |
||||
{ |
||||
return x() * vec.x() + y() * vec.y() + z() * vec.z(); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public V neg() |
||||
{ |
||||
return result(-x(), -y(), -z()); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public V norm(double size) |
||||
{ |
||||
if (isZero()) return result(x(), y(), z()); // can't norm zero vector
|
||||
|
||||
double k = size / size(); |
||||
|
||||
return mul(k); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public int hashCode() |
||||
{ |
||||
int prime = 31; |
||||
int result = 1; |
||||
result = prime * result + Double.valueOf(x()).hashCode(); |
||||
result = prime * result + Double.valueOf(y()).hashCode(); |
||||
result = prime * result + Double.valueOf(z()).hashCode(); |
||||
return result; |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public boolean equals(Object obj) |
||||
{ |
||||
if (this == obj) return true; |
||||
if (obj == null) return false; |
||||
if (!(obj instanceof Vec)) return false; |
||||
Vec other = (Vec) obj; |
||||
|
||||
return x() == other.x() && y() == other.y() && z() == other.z(); |
||||
} |
||||
|
||||
@Override |
||||
public String toString() |
||||
{ |
||||
return String.format("[ %.2f ; %.2f ; %.2f ]", x(), y(), z()); |
||||
} |
||||
} |
||||
@ -0,0 +1,40 @@ |
||||
package mightypork.utils.math.coord; |
||||
|
||||
|
||||
/** |
||||
* Mutable coord interface. This coord can be changed at will. |
||||
* |
||||
* @author MightyPork |
||||
*/ |
||||
public interface VecMutable extends VecArith { |
||||
|
||||
/** |
||||
* Set coordinates to match other coord. |
||||
* |
||||
* @param copied coord whose coordinates are used |
||||
* @return result |
||||
*/ |
||||
VecMutable setTo(Vec copied); |
||||
|
||||
|
||||
/** |
||||
* Set 2D coordinates.<br> |
||||
* Z is unchanged. |
||||
* |
||||
* @param x x coordinate |
||||
* @param y y coordinate |
||||
* @return result |
||||
*/ |
||||
VecMutable setTo(double x, double y); |
||||
|
||||
|
||||
/** |
||||
* Set coordinates. |
||||
* |
||||
* @param x x coordinate |
||||
* @param y y coordinate |
||||
* @param z z coordinate |
||||
* @return result |
||||
*/ |
||||
VecMutable setTo(double x, double y, double z); |
||||
} |
||||
@ -0,0 +1,44 @@ |
||||
package mightypork.utils.math.coord; |
||||
|
||||
|
||||
/** |
||||
* Mutable vec default implementation |
||||
* |
||||
* @author MightyPork |
||||
* @param <V> Return type of methods |
||||
*/ |
||||
abstract class VecMutableImpl<V extends VecMutable> extends VecImpl<V> implements VecMutable { |
||||
|
||||
@Override |
||||
public abstract double x(); |
||||
|
||||
@Override |
||||
public abstract double y(); |
||||
|
||||
@Override |
||||
public abstract double z(); |
||||
|
||||
@Override |
||||
public abstract V result(double x, double y, double z); |
||||
|
||||
|
||||
@Override |
||||
public VecMutable setTo(Vec copied) |
||||
{ |
||||
return result(copied.x(), copied.y(), copied.z()); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public V setTo(double x, double y, double z) |
||||
{ |
||||
return result(x, y, z); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public V setTo(double x, double y) |
||||
{ |
||||
return result(x, y, z()); |
||||
} |
||||
} |
||||
@ -0,0 +1,19 @@ |
||||
package mightypork.utils.math.coord; |
||||
|
||||
import mightypork.utils.math.constraints.VecConstraint; |
||||
|
||||
|
||||
|
||||
/** |
||||
* Read-only coordinate, operations with it will yield a new {@link MutableCoord} with the result. |
||||
* |
||||
* @author MightyPork |
||||
*/ |
||||
public abstract class VecView extends VecImpl<CoordValue> { |
||||
|
||||
@Override |
||||
public CoordValue result(double x, double y, double z) |
||||
{ |
||||
return new CoordValue(x,y,z); |
||||
} |
||||
} |
||||
@ -0,0 +1,398 @@ |
||||
package mightypork.utils.math.rect; |
||||
|
||||
|
||||
import mightypork.utils.math.constraints.RectConstraint; |
||||
import mightypork.utils.math.constraints.VecConstraint; |
||||
import mightypork.utils.math.coord.MutableCoord; |
||||
import mightypork.utils.math.coord.SynthCoord2D; |
||||
import mightypork.utils.math.coord.Vec; |
||||
import mightypork.utils.math.coord.VecMutable; |
||||
import mightypork.utils.math.coord.VecView; |
||||
|
||||
|
||||
public class Rect { |
||||
|
||||
public static final Rect ONE = new Rect(0, 0, 1, 1); // FIXME
|
||||
private final VecMutable pos = new MutableCoord(); |
||||
private final VecMutable size = new MutableCoord(); |
||||
private final VecView center = new SynthCoord2D() { |
||||
|
||||
@Override |
||||
public double y() |
||||
{ |
||||
return pos.x() + size.x() / 2; |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public double x() |
||||
{ |
||||
return pos.y() + size.y() / 2; |
||||
} |
||||
}; |
||||
|
||||
|
||||
/** |
||||
* Create at 0,0 with zero size |
||||
*/ |
||||
public Rect() { |
||||
// keep default zeros
|
||||
} |
||||
|
||||
|
||||
/** |
||||
* Create at 0,0 with given size |
||||
* |
||||
* @param width |
||||
* @param height |
||||
*/ |
||||
public Rect(double width, double height) { |
||||
this.pos.setTo(0, 0); |
||||
this.size.setTo(width, height); |
||||
norm(); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Create at given origin, with given size. |
||||
* |
||||
* @param origin |
||||
* @param width |
||||
* @param height |
||||
*/ |
||||
public Rect(Vec origin, double width, double height) { |
||||
this.pos.setTo(origin); |
||||
this.size.setTo(width, height); |
||||
norm(); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* make sure the rect doesn't have negative size. |
||||
*/ |
||||
private void norm() |
||||
{ |
||||
if (size.x() < 0) { |
||||
pos.sub(-size.x(), 0); |
||||
size.mul(-1, 1); |
||||
} |
||||
|
||||
if (size.y() < 0) { |
||||
pos.sub(0, -size.y()); |
||||
size.mul(1, -1); |
||||
} |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Create at given origin, with given size. |
||||
* |
||||
* @param origin |
||||
* @param size |
||||
*/ |
||||
public Rect(Vec origin, Vec size) { |
||||
this.pos.setTo(origin); |
||||
this.size.setTo(size); |
||||
norm(); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Create at given origin, with given size. |
||||
* |
||||
* @param x |
||||
* @param y |
||||
* @param width |
||||
* @param height |
||||
*/ |
||||
public Rect(double x, double y, double width, double height) { |
||||
pos.setTo(x, y); |
||||
size.setTo(width, height); |
||||
norm(); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Create as copy of another |
||||
* |
||||
* @param other copied |
||||
*/ |
||||
public Rect(Rect other) { |
||||
this(other.pos, other.size); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Set to other rect's coordinates |
||||
* |
||||
* @param rect other rect |
||||
*/ |
||||
public void setTo(Rect rect) |
||||
{ |
||||
setTo(rect.pos, rect.size); |
||||
} |
||||
|
||||
|
||||
public void setTo(Vec origin, Vec size) |
||||
{ |
||||
this.pos.setTo(origin); |
||||
this.size.setTo(size); |
||||
norm(); |
||||
} |
||||
|
||||
|
||||
public void setOrigin(Vec origin) |
||||
{ |
||||
this.pos.setTo(origin); |
||||
norm(); |
||||
} |
||||
|
||||
|
||||
public void setSize(Vec size) |
||||
{ |
||||
this.size.setTo(size); |
||||
norm(); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Add vector to origin |
||||
* |
||||
* @param move offset vector |
||||
* @return result |
||||
*/ |
||||
public Rect move(Vec move) |
||||
{ |
||||
move(move.x(), move.y()); |
||||
return this; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Add X and Y to origin |
||||
* |
||||
* @param x x to add |
||||
* @param y y to add |
||||
* @return result |
||||
*/ |
||||
public Rect move(double x, double y) |
||||
{ |
||||
pos.add(x, y); |
||||
return this; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Get a copy |
||||
* |
||||
* @return copy |
||||
*/ |
||||
public Rect copy() |
||||
{ |
||||
return new Rect(this); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Shrink to sides |
||||
* |
||||
* @param shrink shrink size (horisontal and vertical) |
||||
* @return result |
||||
*/ |
||||
public Rect shrink(Vec shrink) |
||||
{ |
||||
return shrink(shrink.x(), shrink.y()); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Shrink to sides at sides |
||||
* |
||||
* @param x horizontal shrink |
||||
* @param y vertical shrink |
||||
* @return result |
||||
*/ |
||||
public Rect shrink(double x, double y) |
||||
{ |
||||
return shrink(x, y, x, y); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Shrink the rect |
||||
* |
||||
* @param left shrink |
||||
* @param top shrink |
||||
* @param right shrink |
||||
* @param bottom shrink |
||||
* @return result |
||||
*/ |
||||
public Rect shrink(double left, double top, double right, double bottom) |
||||
{ |
||||
pos.add(left, top); |
||||
size.sub(left + right, top + bottom); |
||||
norm(); |
||||
return this; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Grow to sides |
||||
* |
||||
* @param grow grow size (added to each side) |
||||
* @return grown copy |
||||
*/ |
||||
public Rect grow(Vec grow) |
||||
{ |
||||
return grow(grow.x(), grow.y()); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Grow to sides |
||||
* |
||||
* @param x horizontal grow |
||||
* @param y vertical grow |
||||
* @return result |
||||
*/ |
||||
public Rect grow(double x, double y) |
||||
{ |
||||
return grow(x, y, x, y); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Grow the rect |
||||
* |
||||
* @param left growth |
||||
* @param top growth |
||||
* @param right growth |
||||
* @param bottom growth |
||||
* @return result |
||||
*/ |
||||
public Rect grow(double left, double top, double right, double bottom) |
||||
{ |
||||
pos.sub(left, top); |
||||
size.add(left + right, top + bottom); |
||||
norm(); |
||||
return this; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Check if point is inside this rectangle |
||||
* |
||||
* @param point point to test |
||||
* @return is inside |
||||
*/ |
||||
public boolean contains(Vec point) |
||||
{ |
||||
final double x = point.x(), y = point.y(); |
||||
|
||||
final double x1 = pos.x(), y1 = pos.y(); |
||||
final double x2 = x1 + size.x(), y2 = y1 + size.y(); |
||||
|
||||
return x >= x1 && y >= y1 && x <= x2 && y <= y2; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Round coords |
||||
* |
||||
* @return result |
||||
*/ |
||||
public Rect round() |
||||
{ |
||||
pos.round(); |
||||
size.round(); |
||||
return this; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Get offset copy (subtract) |
||||
* |
||||
* @param move offset vector |
||||
* @return result |
||||
*/ |
||||
public Rect sub(Vec move) |
||||
{ |
||||
return sub(move.x(), move.y()); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Subtract X and Y from all coordinates |
||||
* |
||||
* @param x x to subtract |
||||
* @param y y to subtract |
||||
* @return result |
||||
*/ |
||||
Rect sub(double x, double y) |
||||
{ |
||||
pos.sub(x, y); |
||||
norm(); |
||||
return this; |
||||
} |
||||
|
||||
|
||||
public VecView getOrigin() |
||||
{ |
||||
return pos.view(); |
||||
} |
||||
|
||||
|
||||
public VecView getSize() |
||||
{ |
||||
return size.view(); |
||||
} |
||||
|
||||
|
||||
public VecView getCenter() |
||||
{ |
||||
return center; |
||||
} |
||||
|
||||
|
||||
public double getWidth() |
||||
{ |
||||
return size.x(); |
||||
} |
||||
|
||||
|
||||
public double getHeight() |
||||
{ |
||||
return size.y(); |
||||
} |
||||
|
||||
|
||||
@Override |
||||
public String toString() |
||||
{ |
||||
return String.format("[%s-%s]", pos.toString(), pos.view().add(size).toString()); |
||||
} |
||||
|
||||
|
||||
public double xMin() |
||||
{ |
||||
return pos.x(); |
||||
} |
||||
|
||||
|
||||
public double xMax() |
||||
{ |
||||
return pos.x() + size.x(); |
||||
} |
||||
|
||||
|
||||
public double yMin() |
||||
{ |
||||
return pos.y(); |
||||
} |
||||
|
||||
|
||||
public double yMax() |
||||
{ |
||||
return pos.y() + size.y(); |
||||
} |
||||
} |
||||
@ -0,0 +1,276 @@ |
||||
//package mightypork.utils.math.rect;
|
||||
//
|
||||
//import mightypork.utils.math.constraints.NumberConstraint;
|
||||
//import mightypork.utils.math.coord.VecValue;
|
||||
//import mightypork.utils.math.coord.VecView;
|
||||
//import mightypork.utils.math.coord.SynthCoord3D;
|
||||
//
|
||||
//
|
||||
//public class RectCalc {
|
||||
// /* ================= Coords ================= */
|
||||
//
|
||||
// public static NumberConstraint _x(final VecValue c)
|
||||
// {
|
||||
// return c.xc();
|
||||
// }
|
||||
//
|
||||
//
|
||||
// public static NumberConstraint _y(final VecValue c)
|
||||
// {
|
||||
// return c.yc();
|
||||
// }
|
||||
//
|
||||
//
|
||||
// public static NumberConstraint _z(final VecValue c)
|
||||
// {
|
||||
// return c.zc();
|
||||
// }
|
||||
//
|
||||
//
|
||||
// public static VecView _neg(final VecValue c)
|
||||
// {
|
||||
// return _mul(c, -1);
|
||||
// }
|
||||
//
|
||||
//
|
||||
// public static VecView _half(final VecValue c)
|
||||
// {
|
||||
// return _mul(c, 0.5);
|
||||
// }
|
||||
//
|
||||
//
|
||||
// // --- add ---
|
||||
//
|
||||
// public static VecView _add(final VecValue c1, final VecValue c2)
|
||||
// {
|
||||
// return new SynthCoord3D() {
|
||||
//
|
||||
// @Override
|
||||
// public double x()
|
||||
// {
|
||||
// return c1.x() + c2.x();
|
||||
// }
|
||||
//
|
||||
//
|
||||
// @Override
|
||||
// public double y()
|
||||
// {
|
||||
// return c1.y() + c2.y();
|
||||
// }
|
||||
//
|
||||
//
|
||||
// @Override
|
||||
// public double z()
|
||||
// {
|
||||
// return c1.z() + c2.z();
|
||||
// }
|
||||
//
|
||||
// };
|
||||
// }
|
||||
//
|
||||
//
|
||||
// public static VecView _add(final VecValue c, final Object x, final Object y)
|
||||
// {
|
||||
// return _add(c, x, y, 0);
|
||||
// }
|
||||
//
|
||||
//
|
||||
// public static VecView _add(final VecValue c, final Object x, final Object y, final Object z)
|
||||
// {
|
||||
// return new SynthCoord3D() {
|
||||
//
|
||||
// @Override
|
||||
// public double x()
|
||||
// {
|
||||
// return c.x() + num(x);
|
||||
// }
|
||||
//
|
||||
//
|
||||
// @Override
|
||||
// public double y()
|
||||
// {
|
||||
// return c.y() + num(y);
|
||||
// }
|
||||
//
|
||||
//
|
||||
// @Override
|
||||
// public double z()
|
||||
// {
|
||||
// return c.z() + num(z);
|
||||
// }
|
||||
//
|
||||
// };
|
||||
// }
|
||||
//
|
||||
//
|
||||
// // --- sub ---
|
||||
//
|
||||
// public static VecView _sub(final VecValue c1, final VecValue c2)
|
||||
// {
|
||||
// return new SynthCoord3D() {
|
||||
//
|
||||
// @Override
|
||||
// public double x()
|
||||
// {
|
||||
// return c1.x() - c2.x();
|
||||
// }
|
||||
//
|
||||
//
|
||||
// @Override
|
||||
// public double y()
|
||||
// {
|
||||
// return c1.y() - c2.y();
|
||||
// }
|
||||
//
|
||||
//
|
||||
// @Override
|
||||
// public double z()
|
||||
// {
|
||||
// return c1.z() - c2.z();
|
||||
// }
|
||||
//
|
||||
// };
|
||||
// }
|
||||
//
|
||||
//
|
||||
// public static VecView _sub(final VecValue c, final Object x, final Object y)
|
||||
// {
|
||||
// return _add(c, x, y, 0);
|
||||
// }
|
||||
//
|
||||
//
|
||||
// public static VecView _sub(final VecValue c, final Object x, final Object y, final Object z)
|
||||
// {
|
||||
// return new SynthCoord3D() {
|
||||
//
|
||||
// @Override
|
||||
// public double x()
|
||||
// {
|
||||
// return c.x() - num(x);
|
||||
// }
|
||||
//
|
||||
//
|
||||
// @Override
|
||||
// public double y()
|
||||
// {
|
||||
// return c.y() - num(y);
|
||||
// }
|
||||
//
|
||||
//
|
||||
// @Override
|
||||
// public double z()
|
||||
// {
|
||||
// return c.z() - num(z);
|
||||
// }
|
||||
//
|
||||
// };
|
||||
// }
|
||||
//
|
||||
//
|
||||
// // --- mul ---
|
||||
//
|
||||
// public static VecView _mul(final VecValue c, final Object mul)
|
||||
// {
|
||||
// return new SynthCoord3D() {
|
||||
//
|
||||
// @Override
|
||||
// public double x()
|
||||
// {
|
||||
// return c.x() * num(mul);
|
||||
// }
|
||||
//
|
||||
//
|
||||
// @Override
|
||||
// public double y()
|
||||
// {
|
||||
// return c.y() * num(mul);
|
||||
// }
|
||||
//
|
||||
//
|
||||
// @Override
|
||||
// public double z()
|
||||
// {
|
||||
// return c.z() * num(mul);
|
||||
// }
|
||||
//
|
||||
// };
|
||||
// }
|
||||
//
|
||||
// public static VecView _origin(final Rect r)
|
||||
// {
|
||||
// return r.getOrigin().view();
|
||||
// }
|
||||
//
|
||||
//
|
||||
// public static VecView _size(final Rect r)
|
||||
// {
|
||||
// return r.getSize().view();
|
||||
// }
|
||||
//
|
||||
//
|
||||
// public static NumberConstraint _width(final Rect r)
|
||||
// {
|
||||
// return _x(_size(r));
|
||||
// }
|
||||
//
|
||||
//
|
||||
// public static NumberConstraint _height(final Rect r)
|
||||
// {
|
||||
// return _y(_size(r));
|
||||
// }
|
||||
//
|
||||
//
|
||||
// public static VecView _center(final Rect r)
|
||||
// {
|
||||
// return _add(_origin(r), _half(_size(r)));
|
||||
// }
|
||||
//
|
||||
//
|
||||
// public static VecView _top_left(final Rect r)
|
||||
// {
|
||||
// return _origin(r);
|
||||
// }
|
||||
//
|
||||
//
|
||||
// public static VecView _top_right(final Rect r)
|
||||
// {
|
||||
// return _add(_origin(r), _width(r), 0);
|
||||
// }
|
||||
//
|
||||
//
|
||||
// public static VecView _bottom_left(final Rect r)
|
||||
// {
|
||||
// return _add(_origin(r), 0, _height(r));
|
||||
// }
|
||||
//
|
||||
//
|
||||
// public static VecView _bottom_right(final Rect r)
|
||||
// {
|
||||
// return _add(_origin(r), _size(r));
|
||||
// }
|
||||
//
|
||||
//
|
||||
// public static VecView _center_top(final Rect r)
|
||||
// {
|
||||
// return _add(_origin(r), _half(_width(r)), 0);
|
||||
// }
|
||||
//
|
||||
//
|
||||
// public static VecView _center_bottom(final Rect r)
|
||||
// {
|
||||
// return _add(_origin(r), _half(_width(r)), _height(r));
|
||||
// }
|
||||
//
|
||||
//
|
||||
// public static VecView _center_left(final Rect r)
|
||||
// {
|
||||
// return _add(_origin(r), 0, _half(_height(r)));
|
||||
// }
|
||||
//
|
||||
//
|
||||
// public static VecView _center_right(final Rect r)
|
||||
// {
|
||||
// return _add(_origin(r), _width(r), _half(_height(r)));
|
||||
// }
|
||||
//
|
||||
//}
|
||||
@ -0,0 +1,906 @@ |
||||
//package mightypork.utils.math.rect;
|
||||
//
|
||||
//
|
||||
//import mightypork.utils.math.Calc;
|
||||
//import mightypork.utils.math.constraints.NumberConstraint;
|
||||
//import mightypork.utils.math.constraints.RectConstraint;
|
||||
//import mightypork.utils.math.coord.ConstrCoord;
|
||||
//import mightypork.utils.math.coord.VecValue;
|
||||
//import mightypork.utils.math.coord.VecArith;
|
||||
//import mightypork.utils.math.coord.VecMutable;
|
||||
//
|
||||
//
|
||||
///**
|
||||
// * Rectangle determined by two coordinates - min and max.
|
||||
// *
|
||||
// * @author MightyPork
|
||||
// */
|
||||
//public class Rectd implements RectConstraint, IRect {
|
||||
//
|
||||
// public static final IRect ZERO = new Rect(0, 0, 0, 0).freeze();
|
||||
// public static final Rect ONE = new Rect(0, 0, 1, 1).freeze();
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Rectangle from size; coords are copied.
|
||||
// *
|
||||
// * @param min min coord
|
||||
// * @param size rect size
|
||||
// * @return the rect
|
||||
// */
|
||||
// public static Rect fromSize(VecArith min, VecValue size)
|
||||
// {
|
||||
// return fromSize(min, size.xi(), size.yi());
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Make rect from min coord and size; coords are copied.
|
||||
// *
|
||||
// * @param min min coord
|
||||
// * @param width size x
|
||||
// * @param height size y
|
||||
// * @return the new rect
|
||||
// */
|
||||
// public static Rect fromSize(VecArith min, double width, double height)
|
||||
// {
|
||||
// return new Rect(min.copy(), min.add(width, height));
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Rectangle from size
|
||||
// *
|
||||
// * @param sizeX size x
|
||||
// * @param sizeY size y
|
||||
// * @return rect
|
||||
// */
|
||||
// public static IRect fromSize(double sizeX, double sizeY)
|
||||
// {
|
||||
// return fromSize(0, 0, sizeX, sizeY);
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Get rect from size
|
||||
// *
|
||||
// * @param size size
|
||||
// * @return rect
|
||||
// */
|
||||
// public static IRect fromSize(VecValue size)
|
||||
// {
|
||||
// return fromSize(0, 0, size.x(), size.y());
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Make rect from min coord and size
|
||||
// *
|
||||
// * @param xmin min x
|
||||
// * @param ymin min y
|
||||
// * @param width size x
|
||||
// * @param height size y
|
||||
// * @return the new rect
|
||||
// */
|
||||
// public static Rect fromSize(double xmin, double ymin, double width, double height)
|
||||
// {
|
||||
// return new Rect(xmin, ymin, xmin + width, ymin + height);
|
||||
// }
|
||||
//
|
||||
// /** Lowest coordinates xy */
|
||||
// protected final VecArith min;
|
||||
//
|
||||
// /** Highest coordinates xy */
|
||||
// protected final VecArith max;
|
||||
//
|
||||
// // view of secondary corners.
|
||||
//
|
||||
// //@formatter:off
|
||||
// private final ConstrCoord HMinVMax = new ConstrCoord(
|
||||
// new NumberConstraint() {
|
||||
// @Override
|
||||
// public double getValue()
|
||||
// {
|
||||
// return min.x();
|
||||
// }
|
||||
// },
|
||||
// new NumberConstraint() {
|
||||
// @Override
|
||||
// public double getValue()
|
||||
// {
|
||||
// return max.y();
|
||||
// }
|
||||
// },
|
||||
// null
|
||||
// );
|
||||
//
|
||||
//
|
||||
// private final ConstrCoord HMaxVMin = new ConstrCoord(
|
||||
// new NumberConstraint() {
|
||||
// @Override
|
||||
// public double getValue() {
|
||||
// return max.x();
|
||||
// }
|
||||
// },
|
||||
// new NumberConstraint() {
|
||||
// @Override
|
||||
// public double getValue()
|
||||
// {
|
||||
// return min.y();
|
||||
// }
|
||||
// },
|
||||
// null
|
||||
// );
|
||||
// //@formatter:on
|
||||
//
|
||||
// private boolean frozen;
|
||||
//
|
||||
//
|
||||
// public boolean isWritable()
|
||||
// {
|
||||
// return !frozen && !isView();
|
||||
// }
|
||||
//
|
||||
//
|
||||
// public boolean isView()
|
||||
// {
|
||||
// return false;
|
||||
// }
|
||||
//
|
||||
//
|
||||
// public Rect freeze()
|
||||
// {
|
||||
// min.copy();
|
||||
// max.copy();
|
||||
// frozen = true;
|
||||
// return this;
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Get a readonly view
|
||||
// *
|
||||
// * @return view
|
||||
// */
|
||||
// public RectView view()
|
||||
// {
|
||||
// return new RectView(this);
|
||||
// }
|
||||
//
|
||||
//
|
||||
// protected void assertWritable()
|
||||
// {
|
||||
// if (!isWritable()) {
|
||||
// throw new UnsupportedOperationException("This Rect is not writable.");
|
||||
// }
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * New Rect [0, 0, 0, 0]
|
||||
// */
|
||||
// public Rect() {
|
||||
// this(0, 0, 0, 0);
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Rect [0, 0, size.x, size.y]
|
||||
// *
|
||||
// * @param size size coord
|
||||
// */
|
||||
// public Rect(VecValue size) {
|
||||
// this(0, 0, size.x(), size.y());
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * New rect of two coords; Coords are plugged in directly (ie. views can be
|
||||
// * used for frozen rect representing another)
|
||||
// *
|
||||
// * @param min coord 1
|
||||
// * @param max coord 2
|
||||
// */
|
||||
// public Rect(VecValue min, VecValue max) {
|
||||
// this.min = min; // must not copy
|
||||
// this.max = max; // must not copy
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * New Rect
|
||||
// *
|
||||
// * @param xmin lower x
|
||||
// * @param ymin lower y
|
||||
// * @param xmax upper x
|
||||
// * @param ymax upper y
|
||||
// */
|
||||
// public Rect(double xmin, double ymin, double xmax, double ymax) {
|
||||
// min = new VecArith(xmin, ymin);
|
||||
// max = new VecArith(xmax, ymax);
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Rect [0, 0, x, y]
|
||||
// *
|
||||
// * @param x width
|
||||
// * @param y height
|
||||
// */
|
||||
// public Rect(double x, double y) {
|
||||
// this(0, 0, x, y);
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * New rect as a copy of other rect
|
||||
// *
|
||||
// * @param r other rect
|
||||
// */
|
||||
// public Rect(Rect r) {
|
||||
// this(r.min.copy(), r.max.copy());
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Get offset copy (add)
|
||||
// *
|
||||
// * @param move offset vector
|
||||
// * @return offset copy
|
||||
// */
|
||||
// @Override
|
||||
// public Rect move(VecMutable move)
|
||||
// {
|
||||
// return copy().add_ip(move);
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Add X and Y to all coordinates in a copy
|
||||
// *
|
||||
// * @param x x to add
|
||||
// * @param y y to add
|
||||
// * @return copy changed
|
||||
// */
|
||||
// @Override
|
||||
// public Rect move(double x, double y)
|
||||
// {
|
||||
// return move(new VecArith(x, y));
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Offset in place (add)
|
||||
// *
|
||||
// * @param move offset vector
|
||||
// * @return this
|
||||
// */
|
||||
// public Rect add_ip(VecMutable move)
|
||||
// {
|
||||
// min.add_ip(move);
|
||||
// max.add_ip(move);
|
||||
// return this;
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Add X and Y to all coordinates in place
|
||||
// *
|
||||
// * @param x x to add
|
||||
// * @param y y to add
|
||||
// * @return this
|
||||
// */
|
||||
// public IRect add_ip(double x, double y)
|
||||
// {
|
||||
// return add_ip(new VecArith(x, y));
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Get a copy
|
||||
// *
|
||||
// * @return copy
|
||||
// */
|
||||
// @Override
|
||||
// public Rect copy()
|
||||
// {
|
||||
// return new Rect(this);
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Get rect center
|
||||
// *
|
||||
// * @return center
|
||||
// */
|
||||
// @Override
|
||||
// public VecValue getCenter()
|
||||
// {
|
||||
// return min.midTo(max).copy();
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Get center of the lower edge.
|
||||
// *
|
||||
// * @return center
|
||||
// */
|
||||
// @Override
|
||||
// public VecValue getCenterVMin()
|
||||
// {
|
||||
// return new VecArith((max.x() + min.x()) / 2D, min.y()).copy();
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Get center of the left edge.
|
||||
// *
|
||||
// * @return center
|
||||
// */
|
||||
// @Override
|
||||
// public VecValue getCenterHMin()
|
||||
// {
|
||||
// return new VecArith(min.x(), (max.y() + min.y()) / 2D).copy();
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Get center of the right edge.
|
||||
// *
|
||||
// * @return center
|
||||
// */
|
||||
// @Override
|
||||
// public VecValue getCenterHMax()
|
||||
// {
|
||||
// return new VecArith(max.x(), (max.y() + min.y()) / 2D).copy();
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Get center of the top edge.
|
||||
// *
|
||||
// * @return center
|
||||
// */
|
||||
// @Override
|
||||
// public VecValue getCenterVMax()
|
||||
// {
|
||||
// return new VecArith((max.x() + min.x()) / 2D, max.y()).copy();
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Get left bottom
|
||||
// *
|
||||
// * @return center
|
||||
// */
|
||||
// @Override
|
||||
// public VecArith getHMinVMin()
|
||||
// {
|
||||
// return min.view();
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Get left top
|
||||
// *
|
||||
// * @return center
|
||||
// */
|
||||
// @Override
|
||||
// public VecValue getHMinVMax()
|
||||
// {
|
||||
// return HMinVMax;
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Get right bottom
|
||||
// *
|
||||
// * @return center
|
||||
// */
|
||||
// @Override
|
||||
// public VecValue getHMaxVMin()
|
||||
// {
|
||||
// return HMaxVMin;
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Get right top
|
||||
// *
|
||||
// * @return center
|
||||
// */
|
||||
// @Override
|
||||
// public VecArith getHMaxVMax()
|
||||
// {
|
||||
// return max.view();
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Alias for getX2Y2
|
||||
// *
|
||||
// * @return highest coordinates xy
|
||||
// */
|
||||
// @Override
|
||||
// public VecMutable getMax()
|
||||
// {
|
||||
// return getHMaxVMax();
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Alias for getX1Y1
|
||||
// *
|
||||
// * @return lowest coordinates xy
|
||||
// */
|
||||
// @Override
|
||||
// public VecMutable getMin()
|
||||
// {
|
||||
// return getHMinVMin();
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Alias for getX1Y1
|
||||
// *
|
||||
// * @return lowest coordinates xy
|
||||
// */
|
||||
// public VecValue getOrigin()
|
||||
// {
|
||||
// return getHMinVMin();
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Shrink to sides in copy
|
||||
// *
|
||||
// * @param shrink shrink size (added to each side)
|
||||
// * @return shrinkn copy
|
||||
// */
|
||||
// @Override
|
||||
// public IRect shrink(VecValue shrink)
|
||||
// {
|
||||
// return copy().shrink_ip(shrink);
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Shrink to sides in copy
|
||||
// *
|
||||
// * @param x x to add
|
||||
// * @param y y to add
|
||||
// * @return changed copy
|
||||
// */
|
||||
// @Override
|
||||
// public IRect shrink(double x, double y)
|
||||
// {
|
||||
// return copy().shrink_ip(x, y);
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Shrink to sides in place
|
||||
// *
|
||||
// * @param shrink shrink size (added to each side)
|
||||
// * @return this
|
||||
// */
|
||||
// public IRect shrink_ip(VecValue shrink)
|
||||
// {
|
||||
// shrink_ip(shrink.x(), shrink.y());
|
||||
// return this;
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Shrink to sides in place
|
||||
// *
|
||||
// * @param x horizontal shrink
|
||||
// * @param y vertical shrink
|
||||
// * @return this
|
||||
// */
|
||||
// public IRect shrink_ip(double x, double y)
|
||||
// {
|
||||
// min.sub_ip(x, y);
|
||||
// max.add_ip(-x, -y);
|
||||
// return this;
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Shrink the rect
|
||||
// *
|
||||
// * @param xmin shrink
|
||||
// * @param ymin shrink
|
||||
// * @param xmax shrink
|
||||
// * @param ymax shrink
|
||||
// * @return changed copy
|
||||
// */
|
||||
// @Override
|
||||
// public Rect shrink(double xmin, double ymin, double xmax, double ymax)
|
||||
// {
|
||||
// return copy().shrink_ip(xmin, ymin, xmax, ymax);
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Shrink the rect in place
|
||||
// *
|
||||
// * @param xmin shrink
|
||||
// * @param ymin shrink
|
||||
// * @param xmax shrink
|
||||
// * @param ymax shrink
|
||||
// * @return this
|
||||
// */
|
||||
// public Rect shrink_ip(double xmin, double ymin, double xmax, double ymax)
|
||||
// {
|
||||
// min.add_ip(xmin, ymin);
|
||||
// max.add_ip(-xmax, -ymax);
|
||||
// return this;
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Grow to sides in copy
|
||||
// *
|
||||
// * @param grow grow size (added to each side)
|
||||
// * @return grown copy
|
||||
// */
|
||||
// @Override
|
||||
// public IRect grow(VecValue grow)
|
||||
// {
|
||||
// return copy().grow_ip(grow);
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Grow to sides in copy
|
||||
// *
|
||||
// * @param x horizontal grow
|
||||
// * @param y vertical grow
|
||||
// * @return changed copy
|
||||
// */
|
||||
// @Override
|
||||
// public IRect grow(double x, double y)
|
||||
// {
|
||||
// return copy().grow_ip(x, y);
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Grow to sides in place
|
||||
// *
|
||||
// * @param grow grow size (added to each side)
|
||||
// * @return this
|
||||
// */
|
||||
// public IRect grow_ip(VecValue grow)
|
||||
// {
|
||||
// grow_ip(grow.x(), grow.y());
|
||||
// return this;
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Grow to sides in place
|
||||
// *
|
||||
// * @param x horizontal grow
|
||||
// * @param y vertical grow
|
||||
// * @return this
|
||||
// */
|
||||
// public IRect grow_ip(double x, double y)
|
||||
// {
|
||||
// min.sub_ip(x, y);
|
||||
// max.add_ip(x, y);
|
||||
// return this;
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Grow the rect
|
||||
// *
|
||||
// * @param xmin growth
|
||||
// * @param ymin growth
|
||||
// * @param xmax growth
|
||||
// * @param ymax growth
|
||||
// * @return changed copy
|
||||
// */
|
||||
// @Override
|
||||
// public Rect grow(double xmin, double ymin, double xmax, double ymax)
|
||||
// {
|
||||
// return copy().grow_ip(xmin, ymin, xmax, ymax);
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Grow the rect in place
|
||||
// *
|
||||
// * @param xmin growth
|
||||
// * @param ymin growth
|
||||
// * @param xmax growth
|
||||
// * @param ymax growth
|
||||
// * @return this
|
||||
// */
|
||||
// public Rect grow_ip(double xmin, double ymin, double xmax, double ymax)
|
||||
// {
|
||||
// min.add_ip(-xmin, -ymin);
|
||||
// max.add_ip(xmax, ymax);
|
||||
// return this;
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Check if point is inside this rectangle
|
||||
// *
|
||||
// * @param point point to test
|
||||
// * @return is inside
|
||||
// */
|
||||
// @Override
|
||||
// public boolean isInside(VecValue point)
|
||||
// {
|
||||
// return Calc.inRange(point.x(), min.x(), max.x()) && Calc.inRange(point.y(), min.y(), max.y());
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Multiply in copy
|
||||
// *
|
||||
// * @param factor multiplier
|
||||
// * @return offset copy
|
||||
// */
|
||||
// @Override
|
||||
// public IRect mul(double factor)
|
||||
// {
|
||||
// return copy().mul_ip(factor);
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Multiply by number (useful for centered rects)
|
||||
// *
|
||||
// * @param x x multiplier
|
||||
// * @param y y multiplier
|
||||
// * @return copy multiplied
|
||||
// */
|
||||
// @Override
|
||||
// public IRect mul(double x, double y)
|
||||
// {
|
||||
// return copy().mul_ip(x, y);
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Multiply coord in place
|
||||
// *
|
||||
// * @param factor multiplier
|
||||
// * @return this
|
||||
// */
|
||||
// public IRect mul_ip(double factor)
|
||||
// {
|
||||
// min.mul_ip(factor);
|
||||
// max.mul_ip(factor);
|
||||
// return this;
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Multiply coord in place
|
||||
// *
|
||||
// * @param x multiplier x
|
||||
// * @param y multiplier y
|
||||
// * @return this
|
||||
// */
|
||||
// public IRect mul_ip(double x, double y)
|
||||
// {
|
||||
// min.mul_ip(x, y, 1);
|
||||
// max.mul_ip(x, y, 1);
|
||||
// return this;
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Round coords in copy
|
||||
// *
|
||||
// * @return copy, rounded
|
||||
// */
|
||||
// @Override
|
||||
// public Rect round()
|
||||
// {
|
||||
// return new Rect(min.round(), max.round());
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Round this in place
|
||||
// *
|
||||
// * @return this
|
||||
// */
|
||||
// public IRect round_ip()
|
||||
// {
|
||||
// min.round_ip();
|
||||
// max.round_ip();
|
||||
// return this;
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Set to coordinates
|
||||
// *
|
||||
// * @param xmin lower x
|
||||
// * @param ymin lower y
|
||||
// * @param xmax upper x
|
||||
// * @param ymax upper y
|
||||
// */
|
||||
// @Override
|
||||
// public void setTo(double xmin, double ymin, double xmax, double ymax)
|
||||
// {
|
||||
// min.setTo(Math.min(xmin, xmax), Math.min(ymin, ymax));
|
||||
// max.setTo(Math.max(xmin, xmax), Math.max(ymin, ymax));
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Set to other rect's coordinates
|
||||
// *
|
||||
// * @param r other rect
|
||||
// */
|
||||
// @Override
|
||||
// public void setTo(Rect r)
|
||||
// {
|
||||
// min.setTo(r.min);
|
||||
// max.setTo(r.max);
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Subtract X and Y from all coordinates in a copy
|
||||
// *
|
||||
// * @param x x to subtract
|
||||
// * @param y y to subtract
|
||||
// * @return copy changed
|
||||
// */
|
||||
// @Override
|
||||
// public IRect sub(double x, double y)
|
||||
// {
|
||||
// return sub(new VecArith(x, y));
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Get offset copy (subtract)
|
||||
// *
|
||||
// * @param move offset vector
|
||||
// * @return offset copy
|
||||
// */
|
||||
// @Override
|
||||
// public IRect sub(VecMutable move)
|
||||
// {
|
||||
// return copy().sub_ip(move);
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Subtract X and Y from all coordinates in place
|
||||
// *
|
||||
// * @param x x to subtract
|
||||
// * @param y y to subtract
|
||||
// * @return this
|
||||
// */
|
||||
// public IRect sub_ip(double x, double y)
|
||||
// {
|
||||
// return sub_ip(new VecArith(x, y));
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Offset in place (subtract)
|
||||
// *
|
||||
// * @param move offset vector
|
||||
// * @return this
|
||||
// */
|
||||
// public IRect sub_ip(VecMutable move)
|
||||
// {
|
||||
// min.sub_ip(move);
|
||||
// max.sub_ip(move);
|
||||
// return this;
|
||||
// }
|
||||
//
|
||||
//
|
||||
// @Override
|
||||
// public String toString()
|
||||
// {
|
||||
// return String.format("[%s-%s]", min.toString(), max.toString());
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * @return lower x
|
||||
// */
|
||||
// @Override
|
||||
// public double xMin()
|
||||
// {
|
||||
// return min.x();
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * @return upper x
|
||||
// */
|
||||
// @Override
|
||||
// public double xMax()
|
||||
// {
|
||||
// return max.x();
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * @return lower y
|
||||
// */
|
||||
// @Override
|
||||
// public double yMin()
|
||||
// {
|
||||
// return min.y();
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * @return upper y
|
||||
// */
|
||||
// @Override
|
||||
// public double yMax()
|
||||
// {
|
||||
// return max.y();
|
||||
// }
|
||||
//
|
||||
//
|
||||
// @Override
|
||||
// public double getHeight()
|
||||
// {
|
||||
// return max.y() - min.y();
|
||||
// }
|
||||
//
|
||||
//
|
||||
// @Override
|
||||
// public double getWidth()
|
||||
// {
|
||||
// return max.x() - min.x();
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Get size (width, height) as (x,y)
|
||||
// *
|
||||
// * @return coord of width,height
|
||||
// */
|
||||
// public VecValue getSize()
|
||||
// {
|
||||
// return new VecArith(max.x() - min.x(), max.y() - min.y());
|
||||
// }
|
||||
//
|
||||
//
|
||||
// @Override
|
||||
// public Rect getRect()
|
||||
// {
|
||||
// return this;
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Generate zero rect
|
||||
// *
|
||||
// * @return zero
|
||||
// */
|
||||
// public static IRect zero()
|
||||
// {
|
||||
// return ZERO.copy();
|
||||
// }
|
||||
//
|
||||
//
|
||||
// /**
|
||||
// * Generate 0,0-1,1 rect
|
||||
// *
|
||||
// * @return one
|
||||
// */
|
||||
// public static IRect one()
|
||||
// {
|
||||
// return ZERO.copy();
|
||||
// }
|
||||
//}
|
||||
Loading…
Reference in new issue