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.
919 lines
16 KiB
919 lines
16 KiB
package mightypork.utils.math.constraints;
|
|
|
|
|
|
import mightypork.gamecore.control.timing.Poller;
|
|
import mightypork.utils.math.rect.RectVal;
|
|
import mightypork.utils.math.rect.RectView;
|
|
import mightypork.utils.math.vect.Vect;
|
|
import mightypork.utils.math.vect.VectAdapter;
|
|
import mightypork.utils.math.vect.VectVal;
|
|
import mightypork.utils.math.vect.VectView;
|
|
|
|
|
|
/**
|
|
* Constraint factory.<br>
|
|
* Import statically for best experience.
|
|
*
|
|
* @author MightyPork
|
|
*/
|
|
public class ConstraintFactory {
|
|
|
|
public static RectCache cached(final Poller poller, final RectBound rc)
|
|
{
|
|
return new RectCache(poller, rc);
|
|
}
|
|
|
|
|
|
/**
|
|
* Convert {@link Number} to {@link NumBound} if needed
|
|
*
|
|
* @param o unknown numeric value
|
|
* @return converted
|
|
*/
|
|
private static NumBound toNumberBound(final Object o)
|
|
{
|
|
if (o instanceof NumBound) return (NumBound) o;
|
|
|
|
if (o instanceof Number) return new NumBound() {
|
|
|
|
@Override
|
|
public double getValue()
|
|
{
|
|
return ((Number) o).doubleValue();
|
|
}
|
|
};
|
|
|
|
throw new IllegalArgumentException("Invalid numeric type.");
|
|
}
|
|
|
|
|
|
/**
|
|
* Convert {@link Number} or {@link NumBound} to double (current value)
|
|
*
|
|
* @param o unknown numeric value
|
|
* @return double value
|
|
*/
|
|
private static double eval(final Object o)
|
|
{
|
|
return toNumberBound(o).getValue();
|
|
}
|
|
|
|
|
|
public static NumBound min(final Object a, final Object b)
|
|
{
|
|
return new NumBound() {
|
|
|
|
@Override
|
|
public double getValue()
|
|
{
|
|
return Math.min(eval(a), eval(b));
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static NumBound max(final Object a, final Object b)
|
|
{
|
|
return new NumBound() {
|
|
|
|
@Override
|
|
public double getValue()
|
|
{
|
|
return Math.max(eval(a), eval(b));
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static NumBound abs(final NumBound a)
|
|
{
|
|
return new NumBound() {
|
|
|
|
@Override
|
|
public double getValue()
|
|
{
|
|
return Math.abs(a.getValue());
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static NumBound half(final NumBound a)
|
|
{
|
|
return new NumBound() {
|
|
|
|
@Override
|
|
public double getValue()
|
|
{
|
|
return a.getValue() / 2;
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static NumBound round(final NumBound a)
|
|
{
|
|
return new NumBound() {
|
|
|
|
@Override
|
|
public double getValue()
|
|
{
|
|
return Math.round(a.getValue());
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static RectBound round(final RectBound r)
|
|
{
|
|
return new RectBound() {
|
|
|
|
@Override
|
|
public RectView getRect()
|
|
{
|
|
return r.getRect().round();
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static NumBound ceil(final NumBound a)
|
|
{
|
|
return new NumBound() {
|
|
|
|
@Override
|
|
public double getValue()
|
|
{
|
|
return Math.ceil(a.getValue());
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static NumBound floor(final NumBound a)
|
|
{
|
|
return new NumBound() {
|
|
|
|
@Override
|
|
public double getValue()
|
|
{
|
|
return Math.floor(a.getValue());
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static NumBound neg(final NumBound a)
|
|
{
|
|
return new NumBound() {
|
|
|
|
@Override
|
|
public double getValue()
|
|
{
|
|
return -a.getValue();
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static NumBound add(final Object a, final Object b)
|
|
{
|
|
return new NumBound() {
|
|
|
|
@Override
|
|
public double getValue()
|
|
{
|
|
return eval(a) + eval(b);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static NumBound sub(final Object a, final Object b)
|
|
{
|
|
return new NumBound() {
|
|
|
|
@Override
|
|
public double getValue()
|
|
{
|
|
return eval(a) - eval(b);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static NumBound mul(final Object a, final Object b)
|
|
{
|
|
return new NumBound() {
|
|
|
|
@Override
|
|
public double getValue()
|
|
{
|
|
return eval(a) * eval(b);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static NumBound half(final Object a)
|
|
{
|
|
return mul(a, 0.5);
|
|
}
|
|
|
|
|
|
public static NumBound div(final Object a, final Object b)
|
|
{
|
|
return new NumBound() {
|
|
|
|
@Override
|
|
public double getValue()
|
|
{
|
|
return eval(a) / eval(b);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static NumBound perc(final Object whole, final Object percent)
|
|
{
|
|
return new NumBound() {
|
|
|
|
@Override
|
|
public double getValue()
|
|
{
|
|
return eval(whole) * (eval(percent) / 100);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static RectBound row(final RectBound r, final int rows, final int index)
|
|
{
|
|
return new RectBound() {
|
|
|
|
@Override
|
|
public RectView getRect()
|
|
{
|
|
final double height = r.getRect().height();
|
|
final double perRow = height / rows;
|
|
|
|
final Vect origin = r.getRect().origin().add(0, perRow * index);
|
|
final Vect size = r.getRect().size().setY(perRow);
|
|
|
|
return RectVal.make(origin, size);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static RectBound column(final RectBound r, final int columns, final int index)
|
|
{
|
|
return new RectBound() {
|
|
|
|
@Override
|
|
public RectView getRect()
|
|
{
|
|
final double width = r.getRect().width();
|
|
final double perCol = width / columns;
|
|
|
|
final Vect origin = r.getRect().origin().add(perCol * index, 0);
|
|
final Vect size = r.getRect().size().setX(perCol);
|
|
|
|
return RectVal.make(origin, size);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static RectBound tile(final RectBound r, final int rows, final int cols, final int left, final int top)
|
|
{
|
|
return new RectBound() {
|
|
|
|
@Override
|
|
public RectView getRect()
|
|
{
|
|
final double height = r.getRect().height();
|
|
final double width = r.getRect().height();
|
|
final double perRow = height / rows;
|
|
final double perCol = width / cols;
|
|
|
|
final Vect origin = r.getRect().origin().add(perCol * left, perRow * (rows - top - 1));
|
|
|
|
return RectVal.make(origin, perCol, perRow);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static RectBound shrink(RectBound r, Object shrink)
|
|
{
|
|
return shrink(r, shrink, shrink, shrink, shrink);
|
|
}
|
|
|
|
|
|
public static RectBound shrink(RectBound context, Object horiz, Object vert)
|
|
{
|
|
return shrink(context, horiz, vert, horiz, vert);
|
|
}
|
|
|
|
|
|
public static RectBound shrink(final RectBound r, final Object left, final Object top, final Object right, final Object bottom)
|
|
{
|
|
return new RectBound() {
|
|
|
|
@Override
|
|
public RectView getRect()
|
|
{
|
|
return r.getRect().shrink(eval(left), eval(top), eval(right), eval(bottom));
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static RectBound shrinkTop(final RectBound r, final Object shrink)
|
|
{
|
|
return new RectBound() {
|
|
|
|
@Override
|
|
public RectView getRect()
|
|
{
|
|
return r.getRect().shrink(0, eval(shrink), 0, 0);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static RectBound shrinkBottom(final RectBound r, final Object shrink)
|
|
{
|
|
return new RectBound() {
|
|
|
|
@Override
|
|
public RectView getRect()
|
|
{
|
|
return r.getRect().shrink(0, 0, 0, eval(shrink));
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static RectBound shrinkLeft(final RectBound r, final Object shrink)
|
|
{
|
|
return new RectBound() {
|
|
|
|
@Override
|
|
public RectView getRect()
|
|
{
|
|
return r.getRect().shrink(eval(shrink), 0, 0, 0);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static RectBound shrinkRight(final RectBound r, final Object shrink)
|
|
{
|
|
return new RectBound() {
|
|
|
|
@Override
|
|
public RectView getRect()
|
|
{
|
|
return r.getRect().shrink(0, 0, eval(shrink), 0);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static RectBound grow(RectBound r, Object grow)
|
|
{
|
|
return grow(r, grow, grow, grow, grow);
|
|
}
|
|
|
|
|
|
public static RectBound grow(RectBound r, Object horiz, Object vert)
|
|
{
|
|
return grow(r, horiz, vert, horiz, vert);
|
|
}
|
|
|
|
|
|
public static RectBound grow(final RectBound r, final Object left, final Object right, final Object top, final Object bottom)
|
|
{
|
|
return new RectBound() {
|
|
|
|
@Override
|
|
public RectView getRect()
|
|
{
|
|
return r.getRect().grow(eval(left), eval(right), eval(top), eval(bottom));
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static RectBound growUp(final RectBound r, final Object grow)
|
|
{
|
|
return new RectBound() {
|
|
|
|
@Override
|
|
public RectView getRect()
|
|
{
|
|
return r.getRect().grow(0, eval(grow), 0, 0);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static RectBound growDown(final RectBound r, final Object grow)
|
|
{
|
|
return new RectBound() {
|
|
|
|
@Override
|
|
public RectView getRect()
|
|
{
|
|
return r.getRect().grow(0, 0, 0, eval(grow));
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static RectBound growLeft(final RectBound r, final Object grow)
|
|
{
|
|
return new RectBound() {
|
|
|
|
@Override
|
|
public RectView getRect()
|
|
{
|
|
return r.getRect().grow(eval(grow), 0, 0, 0);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static RectBound growRight(final RectBound r, final Object grow)
|
|
{
|
|
return new RectBound() {
|
|
|
|
@Override
|
|
public RectView getRect()
|
|
{
|
|
return r.getRect().grow(0, 0, eval(grow), 0);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static RectBound box(final Object side)
|
|
{
|
|
return box(side, side);
|
|
}
|
|
|
|
|
|
public static RectBound box(final Vect origin, final Object width, final Object height)
|
|
{
|
|
return new RectBound() {
|
|
|
|
@Override
|
|
public RectView getRect()
|
|
{
|
|
return RectVal.make(origin, eval(width), eval(height));
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static RectBound box(final Object width, final Object height)
|
|
{
|
|
return new RectBound() {
|
|
|
|
@Override
|
|
public RectView getRect()
|
|
{
|
|
return RectVal.make(0, 0, eval(width), eval(height));
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static RectBound box(final RectBound r, final Object width, final Object height)
|
|
{
|
|
return new RectBound() {
|
|
|
|
@Override
|
|
public RectView getRect()
|
|
{
|
|
final Vect origin = r.getRect().origin();
|
|
|
|
return RectVal.make(origin.x(), origin.y(), eval(width), eval(height));
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static RectBound box(final RectBound r, final Object x, final Object y, final Object width, final Object height)
|
|
{
|
|
return new RectBound() {
|
|
|
|
@Override
|
|
public RectView getRect()
|
|
{
|
|
final Vect origin = r.getRect().origin();
|
|
|
|
return RectVal.make(origin.x() + eval(x), origin.y() + eval(y), eval(width), eval(height));
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static RectBound centerTo(final RectBound r, final RectBound centerTo)
|
|
{
|
|
return new RectBound() {
|
|
|
|
@Override
|
|
public RectView getRect()
|
|
{
|
|
final VectView size = r.getRect().size();
|
|
final VectView center = centerTo.getRect().center();
|
|
|
|
return RectVal.make(center.sub(size.half()), size);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static RectBound centerTo(final RectBound r, final Vect centerTo)
|
|
{
|
|
return new RectBound() {
|
|
|
|
@Override
|
|
public RectView getRect()
|
|
{
|
|
final VectView size = r.getRect().size();
|
|
|
|
return RectVal.make(centerTo.copy().sub(size.half()), size);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static RectBound centerTo(final RectBound r, final Object x, final Object y)
|
|
{
|
|
return new RectBound() {
|
|
|
|
@Override
|
|
public RectView getRect()
|
|
{
|
|
final VectView size = r.getRect().size();
|
|
final VectView v = VectVal.make(eval(x), eval(y));
|
|
|
|
return RectVal.make(v.sub(size.half()), size);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static RectBound move(final RectBound r, final Vect move)
|
|
{
|
|
return new RectBound() {
|
|
|
|
@Override
|
|
public RectView getRect()
|
|
{
|
|
return r.getRect().move(move);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static RectBound move(final RectBound r, final Object x, final Object y)
|
|
{
|
|
return new RectBound() {
|
|
|
|
@Override
|
|
public RectView getRect()
|
|
{
|
|
return r.getRect().move(eval(x), eval(y));
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
/**
|
|
* Make a rect around coord
|
|
*
|
|
* @param c coord
|
|
* @param allSides size to grow on all sides
|
|
* @return rect constraint
|
|
*/
|
|
public static RectBound expand(final Vect c, final Object allSides)
|
|
{
|
|
return expand(c, allSides, allSides, allSides, allSides);
|
|
}
|
|
|
|
|
|
/**
|
|
* Make a rect around coord
|
|
*
|
|
* @param c coord
|
|
* @param horizontal horisontal grow (left, right)
|
|
* @param vertical vertical grow (top, bottom)
|
|
* @return rect constraint
|
|
*/
|
|
public static RectBound expand(final Vect c, final Object horizontal, final Object vertical)
|
|
{
|
|
return expand(c, horizontal, vertical, horizontal, vertical);
|
|
}
|
|
|
|
|
|
/**
|
|
* Make a rect around coord, growing by given amounts
|
|
*
|
|
* @param c coord
|
|
* @param top
|
|
* @param right
|
|
* @param bottom
|
|
* @param left
|
|
* @return rect constraint
|
|
*/
|
|
public static RectBound expand(final Vect c, final Object top, final Object right, final Object bottom, final Object left)
|
|
{
|
|
return new RectBound() {
|
|
|
|
@Override
|
|
public RectView getRect()
|
|
{
|
|
final double t = eval(top);
|
|
final double r = eval(right);
|
|
final double b = eval(bottom);
|
|
final double l = eval(left);
|
|
|
|
return RectVal.make(c.x() - l, c.y() - t, l + r, t + b);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static RectBound edgeLeft(final RectBound r)
|
|
{
|
|
return new RectBound() {
|
|
|
|
@Override
|
|
public RectView getRect()
|
|
{
|
|
return r.getRect().shrink(0, 0, r.getRect().width(), 0);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static RectBound edgeTop(final RectBound r)
|
|
{
|
|
return new RectBound() {
|
|
|
|
@Override
|
|
public RectView getRect()
|
|
{
|
|
return r.getRect().shrink(0, 0, 0, r.getRect().height());
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static RectBound edgeRight(final RectBound r)
|
|
{
|
|
return new RectBound() {
|
|
|
|
@Override
|
|
public RectView getRect()
|
|
{
|
|
return r.getRect().shrink(r.getRect().width(), 0, 0, 0);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static RectBound edgeBottom(final RectBound r)
|
|
{
|
|
return new RectBound() {
|
|
|
|
@Override
|
|
public RectView getRect()
|
|
{
|
|
return r.getRect().shrink(0, r.getRect().height(), 0, 0);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static VectView neg(final Vect c)
|
|
{
|
|
return mul(c, -1);
|
|
}
|
|
|
|
|
|
public static VectView half(final Vect c)
|
|
{
|
|
return mul(c, 0.5);
|
|
}
|
|
|
|
|
|
public static VectView add(final Vect c1, final Vect c2)
|
|
{
|
|
return new VectAdapter() {
|
|
|
|
@Override
|
|
public VectView getSource()
|
|
{
|
|
return c1.copy().add(c2);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static VectView add(final Vect c, final Object x, final Object y)
|
|
{
|
|
return add(c, x, y, 0);
|
|
}
|
|
|
|
|
|
public static VectView add(final Vect c, final Object x, final Object y, final Object z)
|
|
{
|
|
return new VectAdapter() {
|
|
|
|
@Override
|
|
public VectView getSource()
|
|
{
|
|
return c.copy().add(eval(x), eval(y), eval(z));
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static VectView sub(final Vect c1, final Vect c2)
|
|
{
|
|
return new VectAdapter() {
|
|
|
|
@Override
|
|
public VectView getSource()
|
|
{
|
|
return c1.copy().sub(c2);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static VectView sub(final Vect c, final Object x, final Object y)
|
|
{
|
|
return sub(c, x, y, 0);
|
|
}
|
|
|
|
|
|
public static VectView sub(final Vect c, final Object x, final Object y, final Object z)
|
|
{
|
|
return new VectAdapter() {
|
|
|
|
@Override
|
|
public VectView getSource()
|
|
{
|
|
return c.copy().sub(eval(x), eval(y), eval(z));
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
|
|
public static VectView mul(final Vect c, final Object mul)
|
|
{
|
|
return new VectAdapter() {
|
|
|
|
@Override
|
|
public VectView getSource()
|
|
{
|
|
return c.copy().mul(eval(mul));
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
|
|
public static VectView norm(final Vect c, final Object norm)
|
|
{
|
|
return new VectAdapter() {
|
|
|
|
@Override
|
|
public VectView getSource()
|
|
{
|
|
return c.copy().norm(eval(norm));
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
|
|
public static VectView origin(final RectBound r)
|
|
{
|
|
return new VectAdapter() {
|
|
|
|
@Override
|
|
public VectView getSource()
|
|
{
|
|
return r.getRect().origin();
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static VectView size(final RectBound r)
|
|
{
|
|
return new VectAdapter() {
|
|
|
|
@Override
|
|
public VectView getSource()
|
|
{
|
|
return r.getRect().size();
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
public static NumBound height(final RectBound r)
|
|
{
|
|
return size(r).yc();
|
|
}
|
|
|
|
|
|
public static NumBound width(final RectBound r)
|
|
{
|
|
return size(r).xc();
|
|
}
|
|
|
|
|
|
public static VectView center(final RectBound r)
|
|
{
|
|
return add(origin(r), half(size(r)));
|
|
}
|
|
|
|
|
|
public static VectView topLeft(final RectBound r)
|
|
{
|
|
return origin(r);
|
|
}
|
|
|
|
|
|
public static VectView topRight(final RectBound r)
|
|
{
|
|
return add(origin(r), width(r), 0);
|
|
}
|
|
|
|
|
|
public static VectView bottomLeft(final RectBound r)
|
|
{
|
|
return add(origin(r), 0, width(r));
|
|
}
|
|
|
|
|
|
public static VectView bottomRight(final RectBound r)
|
|
{
|
|
return add(origin(r), size(r));
|
|
}
|
|
|
|
|
|
public static VectView topCenter(final RectBound r)
|
|
{
|
|
return add(origin(r), half(width(r)), 0);
|
|
}
|
|
|
|
|
|
public static VectView bottomCenter(final RectBound r)
|
|
{
|
|
return add(origin(r), half(width(r)), width(r));
|
|
}
|
|
|
|
|
|
public static VectView centerLeft(final RectBound r)
|
|
{
|
|
return add(origin(r), 0, half(width(r)));
|
|
}
|
|
|
|
|
|
public static VectView centerRight(final RectBound r)
|
|
{
|
|
return add(origin(r), width(r), half(width(r)));
|
|
}
|
|
|
|
|
|
/**
|
|
* Zero-sized RectView at given coord
|
|
*
|
|
* @param c coord
|
|
* @return rect
|
|
*/
|
|
public static RectBound zeroRect(final Vect c)
|
|
{
|
|
return new RectBound() {
|
|
|
|
@Override
|
|
public RectView getRect()
|
|
{
|
|
return RectVal.make(c.x(), c.y(), 0, 0);
|
|
}
|
|
};
|
|
}
|
|
|
|
}
|
|
|