You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
486 lines
8.0 KiB
486 lines
8.0 KiB
package mightypork.gamecore.util.math.constraints.rect;
|
|
|
|
|
|
import mightypork.gamecore.util.math.constraints.num.NumConst;
|
|
import mightypork.gamecore.util.math.constraints.rect.caching.RectDigest;
|
|
import mightypork.gamecore.util.math.constraints.vect.Vect;
|
|
import mightypork.gamecore.util.math.constraints.vect.VectConst;
|
|
|
|
|
|
/**
|
|
* Rectangle with constant bounds, that can never change.<br>
|
|
* It's arranged so that operations with constant arguments yield constant
|
|
* results.
|
|
*
|
|
* @author Ondřej Hruška (MightyPork)
|
|
*/
|
|
public class RectConst extends Rect {
|
|
|
|
private final VectConst pos;
|
|
private final VectConst size;
|
|
|
|
// cached with lazy loading
|
|
private NumConst v_b;
|
|
private NumConst v_r;
|
|
private VectConst v_br;
|
|
private VectConst v_tc;
|
|
private VectConst v_tr;
|
|
private VectConst v_cl;
|
|
private VectConst v_c;
|
|
private VectConst v_cr;
|
|
private VectConst v_bl;
|
|
private VectConst v_bc;
|
|
private RectConst v_round;
|
|
private RectConst v_edge_l;
|
|
private RectConst v_edge_r;
|
|
private RectConst v_edge_t;
|
|
private RectConst v_edge_b;
|
|
private RectDigest digest;
|
|
private RectConst v_floor;
|
|
private RectConst v_ceil;
|
|
private RectConst v_axis_v;
|
|
private RectConst v_axis_h;
|
|
|
|
|
|
/**
|
|
* Create at given origin, with given size.
|
|
*
|
|
* @param x
|
|
* @param y
|
|
* @param width
|
|
* @param height
|
|
*/
|
|
RectConst(double x, double y, double width, double height)
|
|
{
|
|
this.pos = Vect.make(x, y);
|
|
this.size = Vect.make(width, height);
|
|
}
|
|
|
|
|
|
/**
|
|
* Create at given origin, with given size.
|
|
*
|
|
* @param origin
|
|
* @param size
|
|
*/
|
|
RectConst(Vect origin, Vect size)
|
|
{
|
|
this.pos = origin.freeze();
|
|
this.size = size.freeze();
|
|
}
|
|
|
|
|
|
/**
|
|
* Create at given origin, with given size.
|
|
*
|
|
* @param another other coord
|
|
*/
|
|
RectConst(Rect another)
|
|
{
|
|
this.pos = another.origin().freeze();
|
|
this.size = another.size().freeze();
|
|
}
|
|
|
|
|
|
/**
|
|
* @deprecated it's useless to copy a constant
|
|
*/
|
|
@Override
|
|
@Deprecated
|
|
public RectConst freeze()
|
|
{
|
|
return this; // already constant
|
|
}
|
|
|
|
|
|
@Override
|
|
public RectDigest digest()
|
|
{
|
|
return (digest != null) ? digest : (digest = super.digest());
|
|
}
|
|
|
|
|
|
@Override
|
|
public VectConst origin()
|
|
{
|
|
return pos;
|
|
}
|
|
|
|
|
|
@Override
|
|
public VectConst size()
|
|
{
|
|
return size;
|
|
}
|
|
|
|
|
|
@Override
|
|
public RectConst move(Vect move)
|
|
{
|
|
return move(move.x(), move.y());
|
|
}
|
|
|
|
|
|
@Override
|
|
public RectConst move(double x, double y)
|
|
{
|
|
return Rect.make(pos.add(x, y), size);
|
|
}
|
|
|
|
|
|
public RectConst move(NumConst x, NumConst y)
|
|
{
|
|
return super.move(x, y).freeze();
|
|
}
|
|
|
|
|
|
@Override
|
|
public RectConst shrink(double left, double right, double top, double bottom)
|
|
{
|
|
return super.shrink(left, right, top, bottom).freeze();
|
|
|
|
}
|
|
|
|
|
|
@Override
|
|
public RectConst grow(double left, double right, double top, double bottom)
|
|
{
|
|
return super.grow(left, right, top, bottom).freeze();
|
|
}
|
|
|
|
|
|
@Override
|
|
public RectConst round()
|
|
{
|
|
return (v_round != null) ? v_round : (v_round = Rect.make(pos.round(), size.round()));
|
|
}
|
|
|
|
|
|
@Override
|
|
public RectConst floor()
|
|
{
|
|
return (v_floor != null) ? v_floor : (v_floor = Rect.make(pos.floor(), size.floor()));
|
|
}
|
|
|
|
|
|
@Override
|
|
public RectConst ceil()
|
|
{
|
|
return (v_ceil != null) ? v_ceil : (v_ceil = Rect.make(pos.ceil(), size.ceil()));
|
|
}
|
|
|
|
|
|
@Override
|
|
public NumConst x()
|
|
{
|
|
return pos.xn();
|
|
}
|
|
|
|
|
|
@Override
|
|
public NumConst y()
|
|
{
|
|
return pos.yn();
|
|
}
|
|
|
|
|
|
@Override
|
|
public NumConst width()
|
|
{
|
|
return size.xn();
|
|
}
|
|
|
|
|
|
@Override
|
|
public NumConst height()
|
|
{
|
|
return size.yn();
|
|
}
|
|
|
|
|
|
@Override
|
|
public NumConst left()
|
|
{
|
|
return pos.xn();
|
|
}
|
|
|
|
|
|
@Override
|
|
public NumConst right()
|
|
{
|
|
return (v_r != null) ? v_r : (v_r = super.right().freeze());
|
|
}
|
|
|
|
|
|
@Override
|
|
public NumConst top()
|
|
{
|
|
return pos.yn();
|
|
}
|
|
|
|
|
|
@Override
|
|
public NumConst bottom()
|
|
{
|
|
return (v_b != null) ? v_b : (v_b = super.bottom().freeze());
|
|
}
|
|
|
|
|
|
@Override
|
|
public VectConst topLeft()
|
|
{
|
|
return pos;
|
|
}
|
|
|
|
|
|
@Override
|
|
public VectConst topCenter()
|
|
{
|
|
return (v_tc != null) ? v_tc : (v_tc = super.topCenter().freeze());
|
|
}
|
|
|
|
|
|
@Override
|
|
public VectConst topRight()
|
|
{
|
|
return (v_tr != null) ? v_tr : (v_tr = super.topRight().freeze());
|
|
}
|
|
|
|
|
|
@Override
|
|
public VectConst centerLeft()
|
|
{
|
|
return (v_cl != null) ? v_cl : (v_cl = super.centerLeft().freeze());
|
|
}
|
|
|
|
|
|
@Override
|
|
public VectConst center()
|
|
{
|
|
return (v_c != null) ? v_c : (v_c = super.center().freeze());
|
|
}
|
|
|
|
|
|
@Override
|
|
public VectConst centerRight()
|
|
{
|
|
return (v_cr != null) ? v_cr : (v_cr = super.centerRight().freeze());
|
|
}
|
|
|
|
|
|
@Override
|
|
public VectConst bottomLeft()
|
|
{
|
|
return (v_bl != null) ? v_bl : (v_bl = super.bottomLeft().freeze());
|
|
}
|
|
|
|
|
|
@Override
|
|
public VectConst bottomCenter()
|
|
{
|
|
return (v_bc != null) ? v_bc : (v_bc = super.bottomCenter().freeze());
|
|
}
|
|
|
|
|
|
@Override
|
|
public VectConst bottomRight()
|
|
{
|
|
return (v_br != null) ? v_br : (v_br = super.bottomRight().freeze());
|
|
}
|
|
|
|
|
|
@Override
|
|
public RectConst leftEdge()
|
|
{
|
|
return (v_edge_l != null) ? v_edge_l : (v_edge_l = super.leftEdge().freeze());
|
|
}
|
|
|
|
|
|
@Override
|
|
public RectConst rightEdge()
|
|
{
|
|
return (v_edge_r != null) ? v_edge_r : (v_edge_r = super.rightEdge().freeze());
|
|
}
|
|
|
|
|
|
@Override
|
|
public RectConst topEdge()
|
|
{
|
|
return (v_edge_t != null) ? v_edge_t : (v_edge_t = super.topEdge().freeze());
|
|
}
|
|
|
|
|
|
@Override
|
|
public RectConst bottomEdge()
|
|
{
|
|
return (v_edge_b != null) ? v_edge_b : (v_edge_b = super.bottomEdge().freeze());
|
|
}
|
|
|
|
|
|
@Override
|
|
public Rect axisV()
|
|
{
|
|
return (v_axis_v != null) ? v_axis_v : (v_axis_v = super.axisV().freeze());
|
|
}
|
|
|
|
|
|
@Override
|
|
public Rect axisH()
|
|
{
|
|
return (v_axis_h != null) ? v_axis_h : (v_axis_h = super.axisH().freeze());
|
|
}
|
|
|
|
|
|
@Override
|
|
public Rect shrink(Vect shrink)
|
|
{
|
|
return super.shrink(shrink);
|
|
}
|
|
|
|
|
|
@Override
|
|
public RectConst shrink(double x, double y)
|
|
{
|
|
return super.shrink(x, y).freeze();
|
|
}
|
|
|
|
|
|
public RectConst shrink(NumConst left, NumConst right, NumConst top, NumConst bottom)
|
|
{
|
|
return super.shrink(left, right, top, bottom).freeze();
|
|
}
|
|
|
|
|
|
public RectConst grow(NumConst left, NumConst right, NumConst top, NumConst bottom)
|
|
{
|
|
return super.grow(left, right, top, bottom).freeze();
|
|
}
|
|
|
|
|
|
@Override
|
|
public RectConst shrinkLeft(double shrink)
|
|
{
|
|
return super.shrinkLeft(shrink).freeze();
|
|
}
|
|
|
|
|
|
@Override
|
|
public RectConst shrinkRight(double shrink)
|
|
{
|
|
return super.shrinkRight(shrink).freeze();
|
|
}
|
|
|
|
|
|
@Override
|
|
public RectConst shrinkTop(double shrink)
|
|
{
|
|
return super.shrinkTop(shrink).freeze();
|
|
}
|
|
|
|
|
|
@Override
|
|
public RectConst shrinkBottom(double shrink)
|
|
{
|
|
return super.shrinkBottom(shrink).freeze();
|
|
}
|
|
|
|
|
|
@Override
|
|
public RectConst growLeft(double shrink)
|
|
{
|
|
return super.growLeft(shrink).freeze();
|
|
}
|
|
|
|
|
|
@Override
|
|
public RectConst growRight(double shrink)
|
|
{
|
|
return super.growRight(shrink).freeze();
|
|
}
|
|
|
|
|
|
@Override
|
|
public RectConst growUp(double shrink)
|
|
{
|
|
return super.growUp(shrink).freeze();
|
|
}
|
|
|
|
|
|
@Override
|
|
public RectConst growDown(double shrink)
|
|
{
|
|
return super.growDown(shrink).freeze();
|
|
}
|
|
|
|
|
|
public RectConst shrinkLeft(NumConst shrink)
|
|
{
|
|
return super.shrinkLeft(shrink).freeze();
|
|
}
|
|
|
|
|
|
public RectConst shrinkRight(NumConst shrink)
|
|
{
|
|
return super.shrinkRight(shrink).freeze();
|
|
}
|
|
|
|
|
|
public RectConst shrinkTop(NumConst shrink)
|
|
{
|
|
return super.shrinkTop(shrink).freeze();
|
|
}
|
|
|
|
|
|
public RectConst shrinkBottom(NumConst shrink)
|
|
{
|
|
return super.shrinkBottom(shrink).freeze();
|
|
}
|
|
|
|
|
|
public RectConst growLeft(NumConst shrink)
|
|
{
|
|
return super.growLeft(shrink).freeze();
|
|
}
|
|
|
|
|
|
public RectConst growRight(NumConst shrink)
|
|
{
|
|
return super.growRight(shrink).freeze();
|
|
}
|
|
|
|
|
|
public RectConst growUp(NumConst shrink)
|
|
{
|
|
return super.growUp(shrink).freeze();
|
|
}
|
|
|
|
|
|
public RectConst growBottom(NumConst shrink)
|
|
{
|
|
return super.growDown(shrink).freeze();
|
|
}
|
|
|
|
|
|
public RectConst centerTo(VectConst point)
|
|
{
|
|
return super.centerTo(point).freeze();
|
|
}
|
|
|
|
|
|
public RectConst centerTo(RectConst parent)
|
|
{
|
|
return super.centerTo(parent).freeze();
|
|
}
|
|
|
|
|
|
public RectConst shrink(NumConst x, NumConst y)
|
|
{
|
|
return super.shrink(x, y).freeze();
|
|
}
|
|
|
|
|
|
public RectConst grow(NumConst x, NumConst y)
|
|
{
|
|
return super.grow(x, y).freeze();
|
|
}
|
|
}
|
|
|