616 lines
17 KiB
C++
616 lines
17 KiB
C++
/* /\ +--------------------------------------------------------------+
|
|
____/ \____ /| - zlib/MIT/Unlicenced game framework licensed to freely use, |
|
|
\ / / | copy, and modify without restriction |
|
|
+--\ ^__^ /--+ | |
|
|
| ~/ \~ | | - originally created at [http://nugget.fun] |
|
|
| ~~~~~~~~~~~~ | +--------------------------------------------------------------+
|
|
| SPACE ~~~~~ | /
|
|
| ~~~~~~~ BOX |/
|
|
+-------------*/
|
|
|
|
#include "Box.hpp"
|
|
|
|
/* Construct a Box by giving a corner coordinate (top left if Y-axis is not inverted, bottom left otherwise) and
|
|
* size (as width, height). The invert_y argument indicates that the Y-coordinate increases from the bottom of
|
|
* the screen to the top rather than the default case where it increases from the top to the bottom. */
|
|
Box::Box(const glm::vec2& corner, const glm::vec2& size, bool invert_y)
|
|
{
|
|
x = corner.x;
|
|
y = corner.y;
|
|
w = size.x;
|
|
h = size.y;
|
|
this->invert_y(invert_y);
|
|
}
|
|
|
|
/* Construct a Box from float arguments: x, y, width, height. If invert_y is set, the Y-axis increases from bottom to
|
|
* top instead of top to bottom. */
|
|
Box::Box(float x, float y, float width, float height, bool invert_y) : Box({x, y}, {width, height}, invert_y) {}
|
|
|
|
/* Construct a Box by passing an SDL_Rect struct, which is of the form {x, y, w, h} and limited to int arguments. */
|
|
Box::Box(const SDL_Rect& rect, bool invert_y) : Box({rect.x, rect.y}, {rect.w, rect.h}, invert_y) {}
|
|
|
|
/* Set inverted Y mode to true, meaning the Y-coordinate increases from the bottom to the top, or false, meaning the
|
|
* Y-coordinate increases from the top to the bottom. */
|
|
void Box::invert_y(bool invert)
|
|
{
|
|
invert_y_state = invert;
|
|
}
|
|
|
|
/* Returns true if Y-axis was set to inverted, meaning the Y-coordinate increases from the bottom to the top, or false,
|
|
* meaning Y-coordinate increases from the top to the bottom. */
|
|
bool Box::inverted_y() const
|
|
{
|
|
return invert_y_state;
|
|
}
|
|
|
|
/* Return the width */
|
|
float Box::width() const
|
|
{
|
|
return w;
|
|
}
|
|
|
|
/* Set the width. Negative values will be clamped to zero. */
|
|
void Box::width(float width)
|
|
{
|
|
w = std::max(width, 0.0f);
|
|
}
|
|
|
|
/* Return the height */
|
|
float Box::height() const
|
|
{
|
|
return h;
|
|
}
|
|
|
|
/* Set the height. Negative values will be clamped to zero. */
|
|
void Box::height(float height)
|
|
{
|
|
h = std::max(height, 0.0f);
|
|
}
|
|
|
|
/* Return the size as a vector {width, height} */
|
|
glm::vec2 Box::size() const
|
|
{
|
|
return {width(), height()};
|
|
}
|
|
|
|
/* Set the size. Negative values will be clamped to zero. */
|
|
void Box::size(const glm::vec2& size, bool preserve_center)
|
|
{
|
|
glm::vec2 center = this->center();
|
|
width(size.x);
|
|
height(size.y);
|
|
if (preserve_center)
|
|
{
|
|
this->center(center);
|
|
}
|
|
}
|
|
|
|
float Box::aspect(bool larger_ratio) const
|
|
{
|
|
if (!larger_ratio || width() > height())
|
|
{
|
|
return width() / height();
|
|
}
|
|
else
|
|
{
|
|
return height() / width();
|
|
}
|
|
}
|
|
|
|
/* Return the area of the box (width * height) */
|
|
float Box::area() const
|
|
{
|
|
return width() * height();
|
|
}
|
|
|
|
/* Return the y coordinate representing the top of the box */
|
|
float Box::top() const
|
|
{
|
|
/* if Y-coordinate increases from bottom to top, use the bottom to determine this value */
|
|
if (inverted_y())
|
|
{
|
|
return bottom() + height();
|
|
}
|
|
/* otherwise use the corner Y-coordinate */
|
|
else
|
|
{
|
|
return y;
|
|
}
|
|
}
|
|
|
|
/* Return the x coordinate representing the right side of the box */
|
|
float Box::right() const
|
|
{
|
|
return left() + width();
|
|
}
|
|
|
|
/* Return the y coordinate representing the bottom of the box */
|
|
float Box::bottom() const
|
|
{
|
|
/* if Y-coordinate increases from bottom to top, use the stored Y-coordinate */
|
|
if (inverted_y())
|
|
{
|
|
return y;
|
|
}
|
|
/* otherwise use the top to determine the bottom value */
|
|
else
|
|
{
|
|
return top() + height();
|
|
}
|
|
}
|
|
|
|
/* Return the x coordinate representing the left side of the box */
|
|
float Box::left() const
|
|
{
|
|
return x;
|
|
}
|
|
|
|
/* Return the x component of the center coordinates */
|
|
float Box::cx() const
|
|
{
|
|
return left() + width() / 2.0f;
|
|
}
|
|
|
|
/* Return the y component of the center coordinates */
|
|
float Box::cy() const
|
|
{
|
|
/* if Y-coordinate increases from bottom to top, add from the bottom */
|
|
if (inverted_y())
|
|
{
|
|
return bottom() + height() / 2.0f;
|
|
}
|
|
/* otherwise add from the top */
|
|
else
|
|
{
|
|
return top() + height() / 2.0f;
|
|
}
|
|
}
|
|
|
|
/* Set the y coordinate of the top of the box. If drag is set, the other sides of the box will remain in the
|
|
* same position, and the top will be moved, altering the size of the box. Otherwise, the box will remain the
|
|
* same size, and the bottom location will change, moving the box but preserving the size. */
|
|
void Box::top(float top, bool drag)
|
|
{
|
|
float delta = top - this->top();
|
|
if (!drag)
|
|
{
|
|
move({0, delta});
|
|
}
|
|
else
|
|
{
|
|
drag_top(delta);
|
|
}
|
|
}
|
|
|
|
/* Drag the top delta amount, leaving the bottom in the same position and altering the size of the box. The top
|
|
* can be dragged past the bottom, in which case the current bottom will become the new top value. */
|
|
void Box::drag_top(float delta)
|
|
{
|
|
float new_location = top() + delta;
|
|
height(std::abs(bottom() - new_location));
|
|
if ((inverted_y() && new_location < bottom()) || (!inverted_y() && new_location > bottom()))
|
|
{
|
|
bottom(new_location);
|
|
}
|
|
else
|
|
{
|
|
top(new_location);
|
|
}
|
|
}
|
|
|
|
/* Set the x coordinate of the right side of the box. If drag is set, the other sides of the box will remain in the
|
|
* same position, and the right will be moved, altering the size of the box. Otherwise, the box will remain the
|
|
* same size, and the left location will change, moving the box but preserving the size. */
|
|
void Box::right(float right, bool drag)
|
|
{
|
|
float delta = right - this->right();
|
|
if (!drag)
|
|
{
|
|
move({delta, 0});
|
|
}
|
|
else
|
|
{
|
|
drag_right(delta);
|
|
}
|
|
}
|
|
|
|
/* Drag the right side delta amount, leaving the left in the same position and altering the size of the box. The right
|
|
* side can be dragged past the left, in which case the current left will become the new right value. */
|
|
void Box::drag_right(float delta)
|
|
{
|
|
float new_location = right() + delta;
|
|
width(std::abs(left() - new_location));
|
|
if (new_location < left())
|
|
{
|
|
left(new_location);
|
|
}
|
|
}
|
|
|
|
/* Set the y coordinate of the bottom of the box. If drag is set, the other sides of the box will remain in the
|
|
* same position, and the bottom will be moved, altering the size of the box. Otherwise, the box will remain the
|
|
* same size, and the top location will change, moving the box but preserving the size. */
|
|
void Box::bottom(float bottom, bool drag)
|
|
{
|
|
float delta = bottom - this->bottom();
|
|
if (!drag)
|
|
{
|
|
move({0, delta});
|
|
}
|
|
else
|
|
{
|
|
drag_bottom(delta);
|
|
}
|
|
}
|
|
|
|
/* Drag the bottom delta amount, leaving the top in the same position and altering the size of the box. The bottom
|
|
* can be dragged past the top, in which case the current top will become the new bottom value. */
|
|
void Box::drag_bottom(float delta)
|
|
{
|
|
float new_location = bottom() + delta;
|
|
height(std::abs(top() - new_location));
|
|
if ((inverted_y() && new_location > top()) || (!inverted_y() && new_location < bottom()))
|
|
{
|
|
top(new_location);
|
|
}
|
|
else
|
|
{
|
|
bottom(new_location);
|
|
}
|
|
}
|
|
|
|
/* Set the x coordinate of the left side of the box. If drag is set, the other sides of the box will remain in the
|
|
* same position, and the left will be moved, altering the size of the box. Otherwise, the box will remain the
|
|
* same size, and the right location will change, moving the box but preserving the size. */
|
|
void Box::left(float left, bool drag)
|
|
{
|
|
float delta = left - this->left();
|
|
if (!drag)
|
|
{
|
|
move({delta, 0});
|
|
}
|
|
else
|
|
{
|
|
drag_left(delta);
|
|
}
|
|
}
|
|
|
|
/* Drag the left side delta amount, leaving the right side in the same position and altering the size of the box.
|
|
* The left side can be dragged past the right, in which case the current right will become the new left value. */
|
|
void Box::drag_left(float delta)
|
|
{
|
|
float new_location = left() + delta;
|
|
if (new_location > right())
|
|
{
|
|
left(right());
|
|
width(new_location - left());
|
|
}
|
|
else
|
|
{
|
|
width(right() - new_location);
|
|
left(new_location);
|
|
}
|
|
}
|
|
|
|
/* Set the center x component */
|
|
void Box::cx(float cx)
|
|
{
|
|
move({cx - this->cx(), 0.0f});
|
|
}
|
|
|
|
/* Set the center y component */
|
|
void Box::cy(float cy)
|
|
{
|
|
move({0.0f, cy - this->cy()});
|
|
}
|
|
|
|
/* Return the coordinates of the top left corner */
|
|
glm::vec2 Box::nw() const
|
|
{
|
|
return {left(), top()};
|
|
}
|
|
|
|
/* Return the coordinates of the center of the top edge */
|
|
glm::vec2 Box::north() const
|
|
{
|
|
return {left() + width() / 2.0f, top()};
|
|
}
|
|
|
|
/* Return the coordinates of the top right corner */
|
|
glm::vec2 Box::ne() const
|
|
{
|
|
return {right(), top()};
|
|
}
|
|
|
|
/* Return the coordinates of the center of the right edge */
|
|
glm::vec2 Box::east() const
|
|
{
|
|
return {right(), top() + height() / 2.0f};
|
|
}
|
|
|
|
/* Return the coordinates of the bottom right corner */
|
|
glm::vec2 Box::se() const
|
|
{
|
|
return {right(), bottom()};
|
|
}
|
|
|
|
/* Return the coordinates of the center of the bottom edge */
|
|
glm::vec2 Box::south() const
|
|
{
|
|
return {left() + width() / 2, bottom()};
|
|
}
|
|
|
|
/* Return the coordinates of the bottom left edge */
|
|
glm::vec2 Box::sw() const
|
|
{
|
|
return {left(), bottom()};
|
|
}
|
|
|
|
/* Return the coordinates of the center of the left edge */
|
|
glm::vec2 Box::west() const
|
|
{
|
|
return {left(), top() + height() / 2.0f};
|
|
}
|
|
|
|
/* Return the center coordinates */
|
|
glm::vec2 Box::center() const
|
|
{
|
|
return {cx(), cy()};
|
|
}
|
|
|
|
/* Move the box by specifying the top left corner coordinates */
|
|
void Box::nw(const glm::vec2& nw)
|
|
{
|
|
move(nw - this->nw());
|
|
}
|
|
|
|
/* Move the box by specifying the center of the top edge */
|
|
void Box::north(const glm::vec2& north)
|
|
{
|
|
move(north - this->north());
|
|
}
|
|
|
|
/* Move the box by specifying the top right corner coordinates */
|
|
void Box::ne(const glm::vec2& ne)
|
|
{
|
|
move(ne - this->ne());
|
|
}
|
|
|
|
/* Move the box by specifying the center of the right edge */
|
|
void Box::east(const glm::vec2& east)
|
|
{
|
|
move(east - this->east());
|
|
}
|
|
|
|
/* Move the box by specifying the bottom right corner coordinates */
|
|
void Box::se(const glm::vec2& se)
|
|
{
|
|
move(se - this->se());
|
|
}
|
|
|
|
/* Move the box by specifying the center of the bottom edge */
|
|
void Box::south(const glm::vec2& south)
|
|
{
|
|
move(south - this->south());
|
|
}
|
|
|
|
/* Move the box by specifying the bottom left corner coordinates */
|
|
void Box::sw(const glm::vec2& sw)
|
|
{
|
|
move(sw - this->sw());
|
|
}
|
|
|
|
/* Move the box by specifying the center of the left edge */
|
|
void Box::west(const glm::vec2& west)
|
|
{
|
|
move(west - this->west());
|
|
}
|
|
|
|
/* Move the box by specifying the center coordinates */
|
|
void Box::center(const glm::vec2& center)
|
|
{
|
|
move(center - this->center());
|
|
}
|
|
|
|
/* Called when a Box instance is converted into an SDL_Rect. Allows passing Box to SDL functions that
|
|
* expect an SDL_Rect instead of an SDL_FRect */
|
|
Box::operator SDL_Rect() const
|
|
{
|
|
return {static_cast<int>(left()), static_cast<int>(top()), static_cast<int>(width()), static_cast<int>(height())};
|
|
}
|
|
|
|
/* Zero out the values of the box coordinates and size */
|
|
void Box::clear()
|
|
{
|
|
x = 0;
|
|
y = 0;
|
|
w = 0;
|
|
h = 0;
|
|
}
|
|
|
|
/* Scale the box by multiplying size by {delta.x, delta.y}. If preserve center is set, the box will be scaled
|
|
* around the center, otherwise the top left corner will remain in place. */
|
|
void Box::scale(glm::vec2 delta, bool preserve_center)
|
|
{
|
|
glm::vec2 center = this->center();
|
|
size(this->size() * delta);
|
|
if (preserve_center)
|
|
{
|
|
this->center(center);
|
|
}
|
|
}
|
|
|
|
/* Scale the box by multiplying both width and height by delta. If preserve center is set, the box will be scaled
|
|
* around the center, otherwise the top left corner will remain in place. */
|
|
void Box::scale(float delta, bool preserve_center)
|
|
{
|
|
scale({delta, delta}, preserve_center);
|
|
}
|
|
|
|
/* Expand (or shrink by passing negative values) the box size by adding delta to the current size. If preserve center
|
|
* is set, the box will expand around the center, otherwise the top left corner will remain in place. */
|
|
void Box::expand(glm::vec2 delta, bool preserve_center)
|
|
{
|
|
glm::vec2 center = this->center();
|
|
size(size() + delta);
|
|
if (preserve_center)
|
|
{
|
|
this->center(center);
|
|
}
|
|
}
|
|
|
|
/* Expand (or shrink by passing negative values) the box size by adding delta to both width and height. If preserve
|
|
* center is set, the box will expand around the center, otherwise the top left corner will remain in place. */
|
|
void Box::expand(float delta, bool preserve_center)
|
|
{
|
|
expand({delta, delta}, preserve_center);
|
|
}
|
|
|
|
/* Move the box in the x and y plane by delta amount */
|
|
void Box::move(const glm::vec2& delta)
|
|
{
|
|
x += delta.x;
|
|
y += delta.y;
|
|
}
|
|
|
|
/* Return a copy of the original box, moved by delta amount in the x and y plane */
|
|
Box Box::stamp(const glm::vec2& delta) const
|
|
{
|
|
Box clone = *this;
|
|
clone.move(delta);
|
|
return clone;
|
|
}
|
|
|
|
/* Returns true if box fits completely inside container, false otherwise. Includes the sides
|
|
* of the box, so if the sides are equal, it is considered inside. */
|
|
bool Box::fits(const Box& container) const
|
|
{
|
|
return
|
|
!(
|
|
((inverted_y() && top() > container.top()) || (!inverted_y() && top() < container.top())) ||
|
|
right() > container.right() ||
|
|
((inverted_y() && bottom() < container.bottom()) || (!inverted_y() && bottom() > container.bottom())) ||
|
|
left() < container.left()
|
|
);
|
|
}
|
|
|
|
/* Removes any part of the box that is not inside the passed crop area box */
|
|
void Box::crop(const Box& area)
|
|
{
|
|
if ((inverted_y() && top() > area.top()) || (!inverted_y() && top() < area.top()))
|
|
{
|
|
top(area.top(), true);
|
|
}
|
|
if (right() > area.right())
|
|
{
|
|
right(area.right(), true);
|
|
}
|
|
if ((inverted_y() && bottom() < area.bottom()) || (!inverted_y() && bottom() > area.bottom()))
|
|
{
|
|
bottom(area.bottom(), true);
|
|
}
|
|
if (left() < area.left())
|
|
{
|
|
left(area.left(), true);
|
|
}
|
|
}
|
|
|
|
/* Returns true if point is inside the box, false otherwise. Includes the edges, so points equal to the edges
|
|
* will return true. */
|
|
bool Box::collide(const glm::vec2& point) const
|
|
{
|
|
return point.x >= left() && point.x <= right() && point.y >= (inverted_y() ? bottom() : top()) && point.y <= (inverted_y() ? top() : bottom());
|
|
}
|
|
|
|
/* Returns true if the line segment intersects the box, false otherwise. If intersection is passed and there is a
|
|
* collision, intersection will be filled with the coordinates of the first intersection found unless the segment
|
|
* is fully within the box not touching any edges. */
|
|
bool Box::collide(const Segment& segment, glm::vec2* intersection) const
|
|
{
|
|
/* do the faster check of whether the square represented by the segment diagonal collides to determine
|
|
* if we should look more closely */
|
|
if (collide(segment.box()))
|
|
{
|
|
/* check if segment intersects any edges, storing the intersection point if so */
|
|
if (segment.intersect({nw(), ne()}, intersection) ||
|
|
segment.intersect({ne(), se()}, intersection) ||
|
|
segment.intersect({sw(), se()}, intersection) ||
|
|
segment.intersect({nw(), sw()}, intersection))
|
|
{
|
|
return true;
|
|
}
|
|
/* check if segment is fully inside the box */
|
|
else if (collide(segment.start()) && collide(segment.end()))
|
|
{
|
|
return true;
|
|
}
|
|
/* otherwise, segment must be outside the box even though its box has collided */
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/* Do segment collision with intersection specified by reference rather than pointer */
|
|
bool Box::collide(const Segment& segment, glm::vec2& intersection) const
|
|
{
|
|
return collide(segment, &intersection);
|
|
}
|
|
|
|
/* Return true if box collides with the passed box, false otherwise. If overlap is passed, it is set to
|
|
* the box representing the area where the two boxes overlap. */
|
|
bool Box::collide(const Box& box, Box* overlap) const
|
|
{
|
|
float top, bottom, h;
|
|
if (inverted_y())
|
|
{
|
|
top = std::min(this->top(), box.top());
|
|
bottom = std::max(this->bottom(), box.bottom());
|
|
h = top - bottom;
|
|
}
|
|
else
|
|
{
|
|
top = std::max(this->top(), box.top());
|
|
bottom = std::min(this->bottom(), box.bottom());
|
|
h = bottom - top;
|
|
}
|
|
float right = std::min(this->right(), box.right());
|
|
float left = std::max(this->left(), box.left());
|
|
float w = right - left;
|
|
bool collide = w > 0 && h > 0;
|
|
if (collide && overlap != nullptr)
|
|
{
|
|
overlap->left(left);
|
|
overlap->top(top);
|
|
overlap->width(w);
|
|
overlap->height(h);
|
|
}
|
|
return collide;
|
|
}
|
|
|
|
/* Do a box to box collision test with overlap passed by reference instead of pointer */
|
|
bool Box::collide(const Box& box, Box& overlap) const
|
|
{
|
|
return collide(box, &overlap);
|
|
}
|
|
|
|
/* Return the string representation of a Box "{left, top, width, height}" */
|
|
std::string Box::string() const
|
|
{
|
|
std::stringstream output;
|
|
output << "{(" << left() << ", " << top() << "), (" << width() << ", " << height() << ")}";
|
|
return output.str();
|
|
}
|
|
|
|
|
|
/* Feed a string representation of the box to the passed ostream */
|
|
std::ostream& std::operator<<(std::ostream& out, const Box& box)
|
|
{
|
|
out << box.string();
|
|
return out;
|
|
}
|