shampoo/spacebox
shampoo
/
spacebox
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

box documentation, remove get/set prefixes from Box and Segment

This commit is contained in:
frank 2021-08-14 19:53:39 -04:00
parent fe3e0bf27f
commit ba44b8e8d5
21 changed files with 545 additions and 430 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
demo/Demo.cpp
View File

@ -143,8 +143,8 @@ Mushroom::Mushroom(Node *parent) : Sprite(parent, "resource/shrooms")
void Mushroom::update()
{
move(direction);
int x = box.get_x();
glm::ivec2 resolution = get_display().get_window_size();
int x = box.left();
glm::ivec2 resolution = get_display().window_size();
if (x > resolution.x or x < 0)
{
direction = -direction;
@ -234,7 +234,7 @@ void Demo::load_gl_context()
vertices.insert(vertices.end(), background_vertices.begin(), background_vertices.end());
vertices.insert(vertices.end(), framerate_indicator_vertices.begin(),
framerate_indicator_vertices.end());
glm::ivec2 resolution = get_display().get_window_size();
glm::ivec2 resolution = get_display().window_size();
projection = glm::perspective(
glm::radians(45.0f), resolution.x / (float) resolution.y, 0.1f,
100.0f);

4
demo/Demo.hpp
View File

@ -46,7 +46,7 @@ struct Mushroom : Sprite
Mushroom(Node*);
void update();
virtual std::string get_class_name() const { return "Mushroom"; }
virtual std::string class_name() const { return "Mushroom"; }
};
@ -71,6 +71,6 @@ struct Demo : Game
void load_gl_context();
void respond(SDL_Event&);
void update();
virtual std::string get_class_name() const { return "Demo"; }
virtual std::string class_name() const { return "Demo"; }
};

6
src/Audio.cpp
View File

@ -57,9 +57,9 @@ void SoundEffect::load_chunk(const fs::path& path)
void SoundEffect::play(float location)
{
play();
Box window_box = get_window_box();
location = std::clamp(location, window_box.get_left(), window_box.get_right());
float location_relative = (location - window_box.get_left()) / window_box.get_w();
Box window = window_box();
location = std::clamp(location, window.left(), window.right());
float location_relative = (location - window.left()) / window.width();
int angle = 270 - location_relative * 180;
Mix_SetPosition(channel, angle, 0);
}

567
src/Box.cpp
View File

@ -2,6 +2,7 @@
#include "Segment.hpp"
#include "Box.hpp"
/* Construct a Box by giving the (x, y) coordinate of the NW point and the size as a 2D vector (width, height) */
Box::Box(const glm::vec2& nw, const glm::vec2& size)
{
x = nw.x;
@ -10,127 +11,138 @@ Box::Box(const glm::vec2& nw, const glm::vec2& size)
h = size.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) : Box({rect.x, rect.y}, {rect.w, rect.h}) {}
float Box::get_x() const
{
return x;
}
float Box::get_y() const
{
return y;
}
float Box::get_w() const
/* Return the width */
float Box::width() const
{
return w;
}
float Box::get_h() const
/* 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;
}
void Box::set_x(float x)
/* Set the height. Negative values will be clamped to zero. */
void Box::height(float height)
{
this->x = x;
h = std::max(height, 0.0f);
}
void Box::set_y(float y)
/* Return the size as a vector {width, height} */
glm::vec2 Box::size() const
{
this->y = y;
return glm::vec2(width(), height());
}
void Box::set_w(float width)
/* Set the size. Negative values will be clamped to zero. */
void Box::size(const glm::vec2& size, bool preserve_center)
{
w = width;
}
void Box::set_h(float height)
{
h = height;
}
glm::vec2 Box::get_size() const
{
return glm::vec2(get_w(), get_h());
}
void Box::set_size(const glm::vec2& size, bool preserve_center)
{
glm::vec2 center = get_center();
set_w(size.x);
set_h(size.y);
glm::vec2 center = this->center();
width(size.x);
height(size.y);
if (preserve_center)
{
set_center(center);
this->center(center);
}
}
/* Returns width divided by height regardless of which side is longer */
/* Returns width divided by height. Returns a value regardless of which side is longer, so it can return values
* greater or less than 0. */
float Box::aspect() const
{
return get_w() / get_h();
return width() / height();
}
float Box::get_area() const
/* Return the area of the box (width * height) */
float Box::area() const
{
return get_w() * get_h();
return width() * height();
}
float Box::get_top() const
/* Return the y coordinate representing the top of the box */
float Box::top() const
{
return get_y();
return y;
}
float Box::get_right() const
/* Return the x coordinate representing the right side of the box */
float Box::right() const
{
return get_x() + get_w();
return left() + width();
}
float Box::get_bottom() const
/* Return the y coordinate representing the bottom of the box */
float Box::bottom() const
{
return get_y() + get_h();
return top() + height();
}
float Box::get_left() const
/* Return the x coordinate representing the left side of the box */
float Box::left() const
{
return get_x();
return x;
}
float Box::get_center_x() const
/* Return the x component of the center coordinates */
float Box::cx() const
{
return get_left() + get_w() / 2;
return left() + width() / 2;
}
float Box::get_center_y() const
/* Return the y component of the center coordinates */
float Box::cy() const
{
return get_top() + get_h() / 2;
return top() + height() / 2;
}
void Box::set_top(float top, bool drag)
/* 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)
{
if (!drag)
{
set_y(top);
y = top;
}
else
{
drag_top(top - get_top());
drag_top(top - this->top());
}
}
/* 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 previous_top = get_top();
set_top(get_top() + delta);
set_h(get_h() + previous_top - get_top());
float new_location = top() + delta;
if (new_location > bottom())
{
top(bottom());
height(new_location - top());
}
else
{
height(bottom() - new_location);
top(new_location);
}
}
void Box::set_right(float right, bool drag)
/* 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 - get_right();
float delta = right - this->right();
if (!drag)
{
move({delta, 0});
@ -141,17 +153,24 @@ void Box::set_right(float right, bool drag)
}
}
/* 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 previous_right = get_right();
float new_right = get_right() + delta;
set_w(get_w() + new_right - previous_right);
set_right(new_right);
float new_location = right() + delta;
width(std::abs(left() - new_location));
if (new_location < left())
{
left(new_location);
}
}
void Box::set_bottom(float bottom, bool drag)
/* 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 - get_bottom();
float delta = bottom - this->bottom();
if (!drag)
{
move({0, delta});
@ -162,180 +181,230 @@ void Box::set_bottom(float bottom, bool drag)
}
}
/* 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 previous_bottom = get_bottom();
float new_bottom = get_bottom() + delta;
set_h(get_h() + new_bottom - previous_bottom);
set_bottom(new_bottom);
float new_location = bottom() + delta;
height(std::abs(top() - new_location));
if (new_location < top())
{
top(new_location);
}
}
void Box::set_left(float left, bool drag)
/* 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)
{
if (!drag)
{
set_x(left);
x = left;
}
else
{
drag_left(left - get_left());
drag_left(left - this->left());
}
}
/* 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 previous_left = get_left();
set_left(get_left() + delta);
set_w(get_w() + previous_left - get_left());
}
void Box::set_center_x(float x)
{
move({x - get_center_x(), 0});
}
void Box::set_center_y(float y)
{
move({0, y - get_center_y()});
}
glm::vec2 Box::get_nw() const
{
return {get_x(), get_y()};
}
glm::vec2 Box::get_north() const
{
return glm::vec2(get_x() + get_w() / 2, get_y());
}
glm::vec2 Box::get_ne() const
{
return glm::vec2(get_right(), get_y());
}
glm::vec2 Box::get_east() const
{
return glm::vec2(get_right(), get_top() + get_h() / 2);
}
glm::vec2 Box::get_se() const
{
return glm::vec2(get_right(), get_bottom());
}
glm::vec2 Box::get_south() const
{
return glm::vec2(get_left() + get_w() / 2, get_bottom());
}
glm::vec2 Box::get_sw() const
{
return glm::vec2(get_left(), get_bottom());
}
glm::vec2 Box::get_west() const
{
return glm::vec2(get_x(), get_y() + get_h() / 2);
}
glm::vec2 Box::get_center() const
{
return glm::vec2(get_x() + get_w() / 2, get_y() + get_h() / 2);
}
void Box::set_nw(const glm::vec2& nw)
{
move(nw - get_nw());
}
void Box::set_north(const glm::vec2& n)
{
move(n - get_north());
}
void Box::set_ne(const glm::vec2& ne)
{
move(ne - get_ne());
}
void Box::set_east(const glm::vec2& e)
{
move(e - get_east());
}
void Box::set_se(const glm::vec2& se)
{
move(se - get_se());
}
void Box::set_south(const glm::vec2& s)
{
move(s - get_south());
}
void Box::set_sw(const glm::vec2& sw)
{
move(sw - get_sw());
}
void Box::set_west(const glm::vec2& w)
{
move(w - get_west());
}
void Box::set_center(const glm::vec2& center)
{
move(center - get_center());
}
Box::operator SDL_Rect() const
{
return {static_cast<int>(get_x()), static_cast<int>(get_y()), static_cast<int>(get_w()), static_cast<int>(get_h())};
}
void Box::clear()
{
set_nw(glm::vec2(0, 0));
set_size(glm::vec2(0, 0));
}
void Box::scale(glm::vec2 delta, bool preserve_center)
{
glm::vec2 center = get_center();
set_size(get_size() * delta);
if (preserve_center)
float new_location = left() + delta;
if (new_location > right())
{
set_center(center);
left(right());
width(new_location - left());
}
else
{
width(right() - new_location);
left(new_location);
}
}
/* Set the center x component */
void Box::cx(float x)
{
move({x - cx(), 0.0f});
}
/* Set the center y component */
void Box::cy(float y)
{
move({0.0f, y - 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 glm::vec2(left() + width() / 2.0f, top());
}
/* Return the coordinates of the top right corner */
glm::vec2 Box::ne() const
{
return glm::vec2(right(), top());
}
/* Return the coordinates of the center of the right edge */
glm::vec2 Box::east() const
{
return glm::vec2(right(), top() + height() / 2.0f);
}
/* Return the coordinates of the bottom right corner */
glm::vec2 Box::se() const
{
return glm::vec2(right(), bottom());
}
/* Return the coordinates of the center of the bottom edge */
glm::vec2 Box::south() const
{
return glm::vec2(left() + width() / 2, bottom());
}
/* Return the coordinates of the bottom left edge */
glm::vec2 Box::sw() const
{
return glm::vec2(left(), bottom());
}
/* Return the coordinates of the center of the left edge */
glm::vec2 Box::west() const
{
return glm::vec2(left(), top() + height() / 2);
}
/* Return the center coordinates */
glm::vec2 Box::center() const
{
return glm::vec2(left() + width() / 2, top() + height() / 2);
}
/* 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()
{
nw(glm::vec2(0, 0));
size(glm::vec2(0, 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 = get_center();
set_size(get_size() + delta);
glm::vec2 center = this->center();
size(size() + delta);
if (preserve_center)
{
set_center(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)
{
set_x(get_x() + delta.x);
set_y(get_y() + delta.y);
left(left() + delta.x);
top(top() + 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;
@ -343,45 +412,69 @@ Box Box::stamp(const glm::vec2& delta) const
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 !(get_top() < container.get_top() || get_right() > container.get_right() ||
get_bottom() > container.get_bottom() || get_left() < container.get_left());
return !(top() < container.top() || right() > container.right() ||
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 (get_top() < area.get_top())
if (top() < area.top())
{
set_top(area.get_top(), true);
top(area.top(), true);
}
if (get_right() > area.get_right())
if (right() > area.right())
{
set_right(area.get_right(), true);
right(area.right(), true);
}
if (get_bottom() > area.get_bottom())
if (bottom() > area.bottom())
{
set_bottom(area.get_bottom(), true);
bottom(area.bottom(), true);
}
if (get_left() < area.get_left())
if (left() < area.left())
{
set_left(area.get_left(), true);
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 >= get_left() && point.x <= get_right() && point.y >= get_top() && point.y <= get_bottom();
return point.x >= left() && point.x <= right() && point.y >= top() && point.y <= 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
{
if (collide(segment.get_box()))
/* 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()))
{
return segment.intersect({get_nw(), get_ne()}, intersection) ||
segment.intersect({get_ne(), get_se()}, intersection) ||
segment.intersect({get_sw(), get_se()}, intersection) ||
segment.intersect({get_nw(), get_sw()}, intersection);
/* 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
{
@ -389,42 +482,58 @@ bool Box::collide(const Segment& segment, glm::vec2* intersection) const
}
}
/* 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 = std::max(get_top(), box.get_top());
float right = std::min(get_right(), box.get_right());
float bottom = std::min(get_bottom(), box.get_bottom());
float left = std::max(get_left(), box.get_left());
float top = std::max(this->top(), box.top());
float right = std::min(this->right(), box.right());
float bottom = std::min(this->bottom(), box.bottom());
float left = std::max(this->left(), box.left());
float w = right - left;
float h = bottom - top;
bool collide = w > 0 && h > 0;
if (collide && overlap != NULL)
if (collide && overlap != nullptr)
{
overlap->set_x(left);
overlap->set_y(top);
overlap->set_w(w);
overlap->set_h(h);
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);
}
std::ostream& Box::to_string (std::ostream& out) const
/* Map any point in the bounds of a square with x and y between [-, radius] to a circle with specified radius. If
* center is specified, both the square and circle are centered at specified point. The default radius is 1, and the
* default center is (0, 0). Formula taken from http://squircular.blogspot.com/2015/09/mapping-circle-to-square.html */
glm::vec2 Box::map_point_to_circle(const glm::vec2& point, float radius, const glm::vec2& center) const
{
out << "{(" << get_x() << ", " << get_y() << "), (" << get_w() << ", " << get_h() << ")}";
return out;
}
/* 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& operator<< (std::ostream& out, const Box& box)
{
return box.to_string(out);
out << box.string();
return out;
}

84
src/Box.hpp
View File

@ -3,6 +3,7 @@
#include <iostream>
#include <algorithm>
#include <stdexcept>
#include "SDL.h"
@ -19,52 +20,48 @@ public:
Box(const glm::vec2& = {0, 0}, const glm::vec2& = {0, 0});
Box(const SDL_Rect&);
float get_x() const;
float get_y() const;
float get_w() const;
float get_h() const;
void set_x(float);
void set_y(float);
void set_w(float);
void set_h(float);
glm::vec2 get_size() const;
void set_size(const glm::vec2&, bool = false);
float width() const;
void width(float);
float height() const;
void height(float);
glm::vec2 size() const;
void size(const glm::vec2&, bool = false);
float aspect() const;
float get_area() const;
float get_top() const;
float get_right() const;
float get_bottom() const;
float get_left() const;
float get_center_x() const;
float get_center_y() const;
void set_top(float, bool=false);
float area() const;
float top() const;
float right() const;
float bottom() const;
float left() const;
float cx() const;
float cy() const;
void top(float, bool = false);
void drag_top(float);
void set_right(float, bool=false);
void right(float, bool = false);
void drag_right(float);
void set_bottom(float, bool=false);
void bottom(float, bool = false);
void drag_bottom(float);
void set_left(float, bool=false);
void left(float, bool = false);
void drag_left(float);
void set_center_x(float);
void set_center_y(float);
glm::vec2 get_nw() const;
glm::vec2 get_north() const;
glm::vec2 get_ne() const;
glm::vec2 get_east() const;
glm::vec2 get_se() const;
glm::vec2 get_south() const;
glm::vec2 get_sw() const;
glm::vec2 get_west() const;
glm::vec2 get_center() const;
void set_nw(const glm::vec2&);
void set_north(const glm::vec2&);
void set_ne(const glm::vec2&);
void set_east(const glm::vec2&);
void set_se(const glm::vec2&);
void set_south(const glm::vec2&);
void set_sw(const glm::vec2&);
void set_west(const glm::vec2&);
void set_center(const glm::vec2&);
void cx(float);
void cy(float);
glm::vec2 nw() const;
glm::vec2 north() const;
glm::vec2 ne() const;
glm::vec2 east() const;
glm::vec2 se() const;
glm::vec2 south() const;
glm::vec2 sw() const;
glm::vec2 west() const;
glm::vec2 center() const;
void nw(const glm::vec2&);
void north(const glm::vec2&);
void ne(const glm::vec2&);
void east(const glm::vec2&);
void se(const glm::vec2&);
void south(const glm::vec2&);
void sw(const glm::vec2&);
void west(const glm::vec2&);
void center(const glm::vec2&);
operator SDL_Rect() const;
void clear();
void scale(glm::vec2, bool = false);
@ -80,8 +77,9 @@ public:
bool collide(const Segment&, glm::vec2&) const;
bool collide(const Box&, Box* = nullptr) const;
bool collide(const Box&, Box&) const;
virtual std::string get_class_name() const { return "Box"; }
std::ostream& to_string (std::ostream&) const;
glm::vec2 map_point_to_circle(const glm::vec2&, float, const glm::vec2&) const;
virtual std::string class_name() const { return "Box"; }
std::string string() const;
};

2
src/Configuration.hpp
View File

@ -20,7 +20,7 @@ struct Configuration : Node
void merge();
void write();
void write(fs::path path);
virtual std::string get_class_name() const { return "Configuration"; }
virtual std::string class_name() const { return "Configuration"; }
};

22
src/Display.cpp
View File

@ -8,7 +8,7 @@ Display::Display(Node* parent) : Node(parent)
}
/* Return the (x, y) size in pixels of the window as an integer vector */
glm::ivec2 Display::get_window_size() const
glm::ivec2 Display::window_size() const
{
glm::ivec2 size;
SDL_GetWindowSize(const_cast<SDL_Window*>(get_window()), &size.x, &size.y);
@ -16,13 +16,13 @@ glm::ivec2 Display::get_window_size() const
}
/* Return the window dimensions as a Box object */
Box Display::get_window_box() const
Box Display::window_box() const
{
return Box(glm::vec2(0, 0), get_window_size());
return Box(glm::vec2(0, 0), window_size());
}
/* Get the pixel format of display at specified index (defaults to index 0) */
Uint32 Display::get_pixel_format(int display_index) const
Uint32 Display::pixel_format(int display_index) const
{
SDL_DisplayMode display_mode;
if (SDL_GetCurrentDisplayMode(display_index, &display_mode) != 0)
@ -38,7 +38,7 @@ Uint32 Display::get_pixel_format(int display_index) const
/* Fill the supplied, pre-allocated buffer with 32-bit pixels (8 bits per component) from the GL
* read buffer if in GL context or from the SDL renderer if in SDL context */
void Display::get_screen_pixels(unsigned char* pixels, int w, int h, int x, int y) const
void Display::screen_pixels(unsigned char* pixels, int w, int h, int x, int y) const
{
if (get_root()->is_gl_context)
{
@ -65,19 +65,19 @@ void Display::get_screen_pixels(unsigned char* pixels, int w, int h, int x, int
}
}
SDL_Surface* Display::get_screen_surface() const
SDL_Surface* Display::screen_surface() const
{
glm::ivec2 size = get_window_size();
glm::ivec2 size = window_size();
unsigned char* pixels = new unsigned char[bpp / 8 * size.x * size.y];
get_screen_pixels(pixels, size.x, size.y);
SDL_Surface* surface = get_screen_surface_from_pixels(pixels, get_root()->is_gl_context);
screen_pixels(pixels, size.x, size.y);
SDL_Surface* surface = screen_surface_from_pixels(pixels, get_root()->is_gl_context);
delete[] pixels;
return surface;
}
SDL_Surface* Display::get_screen_surface_from_pixels(unsigned char* pixels, bool flip) const
SDL_Surface* Display::screen_surface_from_pixels(unsigned char* pixels, bool flip) const
{
glm::ivec2 size = get_window_size();
glm::ivec2 size = window_size();
SDL_Surface* surface;
Uint32 rmask, gmask, bmask, amask;
#if SDL_BYTEORDER == SDL_BIG_ENDIAN

16
src/Display.hpp
View File

@ -13,18 +13,20 @@
#include "Node.hpp"
#include "Box.hpp"
struct Display : Node
class Display : public Node
{
public:
const static int bpp = 32;
Display(Node*);
glm::ivec2 get_window_size() const;
Uint32 get_pixel_format(int = 0) const;
Box get_window_box() const;
void get_screen_pixels(unsigned char*, int, int, int = 0, int = 0) const;
SDL_Surface* get_screen_surface() const;
SDL_Surface* get_screen_surface_from_pixels(unsigned char*, bool) const;
glm::ivec2 window_size() const;
Uint32 pixel_format(int = 0) const;
Box window_box() const;
void screen_pixels(unsigned char*, int, int, int = 0, int = 0) const;
SDL_Surface* screen_surface() const;
SDL_Surface* screen_surface_from_pixels(unsigned char*, bool) const;
void respond(SDL_Event&);
void toggle_fullscreen() const;

2
src/Game.cpp
View File

@ -35,7 +35,7 @@ void FramerateIndicator::refresh()
SDL_Texture* texture = SDL_CreateTextureFromSurface(get_root()->get_renderer(), surface);
add_frames(texture);
SDL_FreeSurface(surface);
set_ne(get_display().get_window_box().get_ne());
set_ne(get_display().window_box().ne());
}
}

2
src/Game.hpp
View File

@ -112,7 +112,7 @@ public:
float get_frame_length() const;
void handle_quit_event(SDL_Event&);
void quit();
virtual std::string get_class_name() const { return "Game"; }
virtual std::string class_name() const { return "Game"; }
~Game();
/* Applies delta timing to a value: returns the value as weighted by the amount of time passed since the

2
src/Input.hpp
View File

@ -60,7 +60,7 @@ struct Input : Node
void suppress();
void unsuppress();
bool is_suppressed();
virtual std::string get_class_name() const { return "Input"; }
virtual std::string class_name() const { return "Input"; }
};

6
src/Node.cpp
View File

@ -99,9 +99,9 @@ const Game* Node::get_root() const
return dynamic_cast<const Game*>(r);
}
Box Node::get_window_box()
Box Node::window_box()
{
return get_display().get_window_box();
return get_display().window_box();
}
void Node::suppress_input()
@ -140,7 +140,7 @@ const std::string Node::get_branch_as_string() const
std::stringstream branch;
while (current != nullptr)
{
branch << current->get_class_name() << " @ " << current;
branch << current->class_name() << " @ " << current;
if (current->parent != nullptr)
{
branch << " -> ";

6
src/Node.hpp
View File

@ -12,7 +12,7 @@
class Game;
struct Delegate;
struct Display;
class Display;
struct Input;
class Box;
struct Audio;
@ -43,14 +43,14 @@ public:
Input& get_input();
Audio& get_audio();
const Game* get_root() const;
Box get_window_box();
Box window_box();
void suppress_input();
void suppress_input_temporarily(int = 0);
void unsuppress_input();
void log(const std::string&) const;
void debug(const std::string&) const;
const std::string get_branch_as_string() const;
virtual std::string get_class_name() const { return "Node"; };
virtual std::string class_name() const { return "Node"; };
virtual ~Node();
template<typename T = Game>

14
src/Recorder.cpp
View File

@ -63,7 +63,7 @@ void Recorder::respond(SDL_Event& event)
void Recorder::capture_screen()
{
nlohmann::json config = get_configuration();
SDL_Surface* surface = get_display().get_screen_surface();
SDL_Surface* surface = get_display().screen_surface();
fs::path directory = config["recording"]["screenshot-directory"];
fs::create_directories(directory);
std::string prefix = config["recording"]["screenshot-prefix"].get<std::string>();
@ -147,10 +147,10 @@ void Recorder::open_audio_file()
void Recorder::add_frame()
{
glm::ivec2 size = get_display().get_window_size();
glm::ivec2 size = get_display().window_size();
int bytes = Display::bpp / 8 * size.x * size.y;
unsigned char* pixels = new unsigned char[bytes];
get_display().get_screen_pixels(pixels, size.x, size.y);
get_display().screen_pixels(pixels, size.x, size.y);
int max_length = get_configuration()["recording"]["max-stash-length"];
float length = frame_length() * current_stash.pixel_buffers.size();
if (length > max_length)
@ -177,7 +177,7 @@ void Recorder::add_frame()
// std::vector<bool> flipped = video_stashes.back().flipped;
// for (int ii = frame_offset; ii < pixel_buffers.size() + frame_offset; ii++)
// {
// SDL_Surface* frame = get_display().get_screen_surface_from_pixels(
// SDL_Surface* frame = get_display().screen_surface_from_pixels(
// pixel_buffers[ii - frame_offset], flipped[ii - frame_offset]);
// std::stringstream name;
// name << sfw::pad(ii, 5) << ".png";
@ -199,7 +199,7 @@ void Recorder::add_frame()
int Recorder::get_memory_size()
{
glm::ivec2 window = get_display().get_window_size();
glm::ivec2 window = get_display().window_size();
int bytes_per_frame = Display::bpp / 8 * window.x * window.y,
size_in_bytes = 0;
for (Stash& stash : in_game_stashes)
@ -248,7 +248,7 @@ void Recorder::write_stash_frames(Stash* stash)
float elapsed = 0, last_gif_write = 0, gif_write_overflow = 0;
for (int ii = stash->frame_offset; not stash->pixel_buffers.empty(); ii++)
{
frame = get_display().get_screen_surface_from_pixels(
frame = get_display().screen_surface_from_pixels(
stash->pixel_buffers.front(), stash->flipped.front());
std::stringstream name;
name << sfw::pad(ii, 5) << ".png";
@ -339,7 +339,7 @@ void Recorder::finish_writing_video()
* This requires ffmpeg to be installed on the user's system. Might only work on Linux (?) */
void Recorder::write_mp4()
{
glm::ivec2 size = get_display().get_window_size();
glm::ivec2 size = get_display().window_size();
std::ostringstream mp4_command;
std::string pixel_format = get_configuration()["recording"]["mp4-pixel-format"].get<std::string>();
fs::path images_match = current_video_directory / "%05d.png";

2
src/Recorder.hpp
View File

@ -68,7 +68,7 @@ public:
void write_mp4();
void write_audio(Uint8*, int);
void update();
virtual std::string get_class_name() const { return "Recorder"; }
virtual std::string class_name() const { return "Recorder"; }
};

76
src/Segment.cpp
View File

@ -3,39 +3,43 @@
#include "Box.hpp"
#include "Segment.hpp"
Segment::Segment(const glm::vec2& start, const glm::vec2& end) : start(start), end(end) {};
Segment::Segment(const glm::vec2& start, const glm::vec2& end)
{
this->start(start);
this->end(end);
}
Segment::Segment() : Segment({0, 0}, {0, 0}) {};
Segment::Segment(const glm::vec2& location) : Segment(location, location) {};
Segment::Segment(const Box& start, const Box& end) : Segment(start.get_center(), end.get_center()) {};
Segment::Segment(const Box& start, const Box& end) : Segment(start.center(), end.center()) {};
glm::vec2 Segment::get_start() const
inline glm::vec2 Segment::start() const
{
return start;
return start_;
}
void Segment::set_start(const glm::vec2& s)
void Segment::start(const glm::vec2& start)
{
start = s;
start_ = start;
}
glm::vec2 Segment::get_end() const
glm::vec2 Segment::end() const
{
return end;
return end_;
}
void Segment::set_end(const glm::vec2& e)
void Segment::end(const glm::vec2& end)
{
end = e;
end_ = end;
}
// taken from http://www.realtimerendering.com/resources/GraphicsGems/gemsii/xlines.c
bool Segment::intersect(const Segment& segment, glm::vec2* intersection) const
{
float x1 = start.x, y1 = start.y, x2 = end.x, y2 = end.y, x3 = segment.start.x,
y3 = segment.start.y, x4 = segment.end.x, y4 = segment.end.y;
float x1 = start_.x, y1 = start_.y, x2 = end_.x, y2 = end_.y, x3 = segment.start_.x,
y3 = segment.start_.y, x4 = segment.end_.x, y4 = segment.end_.y;
float a1, a2, b1, b2, c1, c2; // Coefficients of line eqns.
float r1, r2, r3, r4; // 'Sign' values
@ -99,58 +103,58 @@ bool Segment::intersect(const Segment& segment, glm::vec2& intersection) const
return intersect(segment, &intersection);
}
float Segment::get_dx() const
float Segment::dx() const
{
return end.x - start.x;
return end_.x - start_.x;
}
float Segment::get_dy() const
float Segment::dy() const
{
return end.y - start.y;
return end_.y - start_.y;
}
float Segment::get_length() const
float Segment::length() const
{
return glm::distance(start, end);
return glm::distance(start_, end_);
}
Box Segment::get_box() const
Box Segment::box() const
{
float x = std::min(start.x, end.x);
float y = std::min(start.y, end.y);
float w = std::abs(get_dx());
float h = std::abs(get_dy());
float x = std::min(start_.x, end_.x);
float y = std::min(start_.y, end_.y);
float w = std::abs(dx());
float h = std::abs(dy());
return Box({x, y}, {w, h});
}
void Segment::move(const glm::vec2& delta)
{
start += delta;
end += delta;
start_ += delta;
end_ += delta;
}
glm::vec2 Segment::get_center() const
glm::vec2 Segment::center() const
{
return get_subsegments(2)[0].end;
return subsegments(2)[0].end_;
}
glm::vec2 Segment::get_step(float speed) const
glm::vec2 Segment::step(float speed) const
{
float angle = glm::atan(end.x - start.x, end.y - start.y);
float angle = glm::atan(end_.x - start_.x, end_.y - start_.y);
return glm::vec2(speed * glm::sin(angle), speed * glm::cos(angle));
}
glm::vec2 Segment::get_step_relative(float relative_length_per_step) const
glm::vec2 Segment::step_relative(float relative_length_per_step) const
{
return get_step(glm::distance(start, end) * relative_length_per_step);
return step(glm::distance(start_, end_) * relative_length_per_step);
}
std::vector<Segment> Segment::get_subsegments(int count) const
std::vector<Segment> Segment::subsegments(int count) const
{
glm::vec2 step = get_step_relative(1.0f / count);
glm::vec2 step = step_relative(1.0f / count);
std::vector<Segment> subsegments;
subsegments.reserve(count);
glm::vec2 subsegment_start = start, subsegment_end;
glm::vec2 subsegment_start = start_, subsegment_end;
for (int ii = 0; ii < count; ii++)
{
subsegment_end = subsegment_start + step;
@ -162,7 +166,7 @@ std::vector<Segment> Segment::get_subsegments(int count) const
std::ostream& operator<<(std::ostream& out, const Segment& segment)
{
out << "{(" << segment.start.x << ", " << segment.start.y << "), (" <<
segment.end.x << ", " << segment.end.y << ")}";
out << "{(" << segment.start().x << ", " << segment.start().y << "), (" <<
segment.end().x << ", " << segment.end().y << ")}";
return out;
}

36
src/Segment.hpp
View File

@ -13,31 +13,33 @@ struct Sprite;
class Segment
{
private:
glm::vec2 start_, end_;
public:
glm::vec2 start, end;
Segment(const glm::vec2&, const glm::vec2&);
Segment();
Segment(const glm::vec2&);
Segment(const Box&, const Box&);
Segment(const Sprite&, const Sprite&);
glm::vec2 get_start() const;
void set_start(const glm::vec2&);
glm::vec2 get_end() const;
void set_end(const glm::vec2&);
inline glm::vec2 start() const;
void start(const glm::vec2&);
glm::vec2 end() const;
void end(const glm::vec2&);
bool intersect(const Segment&, glm::vec2* = nullptr) const;
bool intersect(const Segment&, glm::vec2&) const;
float get_dx() const;
float get_dy() const;
float get_length() const;
Box get_box() const;
float dx() const;
float dy() const;
float length() const;
Box box() const;
void move(const glm::vec2&);
glm::vec2 get_center() const;
glm::vec2 get_step(float) const;
glm::vec2 get_step_relative(float) const;
std::vector<Segment> get_subsegments(int) const;
inline bool operator<(const Segment& segment) const { return operator<(segment.get_length()); }
glm::vec2 center() const;
glm::vec2 step(float) const;
glm::vec2 step_relative(float) const;
std::vector<Segment> subsegments(int) const;
inline bool operator<(const Segment& segment) const { return operator<(segment.length()); }
/*
std::cout << (a < b) << (a > b) << (b < c) << (b <= c) << (c > b) << (c >= b) << (d < 1) << (d < 2) <<
@ -47,10 +49,10 @@ public:
*/
template<typename N>
inline bool operator<(const N& other) const { return get_length() < other; }
inline bool operator<(const N& other) const { return length() < other; }
template<typename N>
inline bool operator>(const N& other) const { return other < get_length(); }
inline bool operator>(const N& other) const { return other < length(); }
template<typename N>
inline bool operator<=(const N& other) const { return !operator>(other); }

78
src/Sprite.cpp
View File

@ -197,7 +197,7 @@ void Sprite::update_size(bool preserve_center)
{
for (std::size_t ii = 0; ii < boxes.size(); ii++)
{
boxes[ii].set_size(get_current_frameset().get_size(), preserve_center);
boxes[ii].size(get_current_frameset().get_size(), preserve_center);
if (scale != 1)
{
boxes[ii].scale(scale, preserve_center);
@ -307,92 +307,92 @@ const SDL_Color& Sprite::get_color_mod() const
float Sprite::get_w() const
{
return get_box().get_w();
return get_box().width();
}
float Sprite::get_h() const
{
return get_box().get_h();
return get_box().height();
}
glm::vec2 Sprite::get_size() const
{
return get_box().get_size();
return get_box().size();
}
float Sprite::get_top(int index) const
{
return get_box(index).get_top();
return get_box(index).top();
}
float Sprite::get_right(int index) const
{
return get_box(index).get_right();
return get_box(index).right();
}
float Sprite::get_bottom(int index) const
{
return get_box(index).get_bottom();
return get_box(index).bottom();
}
float Sprite::get_left(int index) const
{
return get_box(index).get_left();
return get_box(index).left();
}
float Sprite::get_center_x(int index) const
{
return get_box(index).get_center_x();
return get_box(index).cx();
}
float Sprite::get_center_y(int index) const
{
return get_box(index).get_center_y();
return get_box(index).cy();
}
glm::vec2 Sprite::get_nw(int index) const
{
return get_box(index).get_nw();
return get_box(index).nw();
}
glm::vec2 Sprite::get_north(int index) const
{
return get_box(index).get_north();
return get_box(index).north();
}
glm::vec2 Sprite::get_ne(int index) const
{
return get_box(index).get_ne();
return get_box(index).ne();
}
glm::vec2 Sprite::get_east(int index) const
{
return get_box(index).get_east();
return get_box(index).east();
}
glm::vec2 Sprite::get_se(int index) const
{
return get_box(index).get_se();
return get_box(index).se();
}
glm::vec2 Sprite::get_south(int index) const
{
return get_box(index).get_south();
return get_box(index).south();
}
glm::vec2 Sprite::get_sw(int index) const
{
return get_box(index).get_sw();
return get_box(index).sw();
}
glm::vec2 Sprite::get_west(int index) const
{
return get_box(index).get_west();
return get_box(index).west();
}
glm::vec2 Sprite::get_center(int index) const
{
return get_box(index).get_center();
return get_box(index).center();
}
void Sprite::set_top(float top)
@ -467,7 +467,7 @@ void Sprite::set_center(const glm::vec2& center)
void Sprite::add_wrap(bool x, bool y)
{
add_wrap(x, y, get_display().get_window_box());
add_wrap(x, y, get_display().window_box());
}
void Sprite::add_wrap(bool x, bool y, Box frame)
@ -478,15 +478,15 @@ void Sprite::add_wrap(bool x, bool y, Box frame)
{
if (x)
{
add_box({frame.get_w(), 0});
add_box({frame.width(), 0});
}
if (y)
{
add_box({0, frame.get_h()});
add_box({0, frame.height()});
}
if (x && y)
{
add_box({frame.get_w(), frame.get_h()});
add_box({frame.width(), frame.height()});
}
}
wrap_frame = frame;
@ -510,24 +510,24 @@ glm::vec2 Sprite::move(const glm::vec2& delta)
}
if (wrap.x)
{
if (get_right() > wrap_frame.get_right())
if (get_right() > wrap_frame.right())
{
move({-wrap_frame.get_w(), 0});
move({-wrap_frame.width(), 0});
}
else if (get_right() < wrap_frame.get_left())
else if (get_right() < wrap_frame.left())
{
move({wrap_frame.get_w(), 0});
move({wrap_frame.width(), 0});
}
}
if (wrap.y)
{
if (get_bottom() > wrap_frame.get_bottom())
if (get_bottom() > wrap_frame.bottom())
{
move({0, -wrap_frame.get_h()});
move({0, -wrap_frame.height()});
}
else if (get_bottom() < wrap_frame.get_top())
else if (get_bottom() < wrap_frame.top())
{
move({0, wrap_frame.get_h()});
move({0, wrap_frame.height()});
}
}
return delta;
@ -626,7 +626,7 @@ bool Sprite::collide(const Box& box, bool precise, Box* overlap, bool all, SDL_T
else
{
collision_check_frame = sfw::duplicate_texture(
const_cast<SDL_Renderer*>(get_renderer()), get_current_frame(), get_box(ii).get_size());
const_cast<SDL_Renderer*>(get_renderer()), get_current_frame(), get_box(ii).size());
}
Pixels region_pixels = Pixels(
const_cast<SDL_Renderer*>(get_renderer()), collision_check_frame, overlap->stamp(-get_nw(ii)));
@ -647,7 +647,7 @@ bool Sprite::collide(const Box& box, bool precise, Box* overlap, bool all, SDL_T
else
{
Pixels other_region_pixels = Pixels(
const_cast<SDL_Renderer*>(get_renderer()), other_texture, overlap->stamp(-box.get_nw()));
const_cast<SDL_Renderer*>(get_renderer()), other_texture, overlap->stamp(-box.nw()));
for (int x = 0; x < region_pixels.rect.w && x < other_region_pixels.rect.w; x++)
{
for (int y = 0; y < region_pixels.rect.h && y < other_region_pixels.rect.h; y++)
@ -711,7 +711,7 @@ bool Sprite::collide(const Sprite& sprite, bool precise, Box* overlap, bool all,
else
{
other_sprite_collision_check_texture = sfw::duplicate_texture(
const_cast<SDL_Renderer*>(get_renderer()), sprite.get_current_frame(), sprite.get_box(ii).get_size());
const_cast<SDL_Renderer*>(get_renderer()), sprite.get_current_frame(), sprite.get_box(ii).size());
}
}
if (collide(sprite.get_box(ii), precise, overlap, all, other_sprite_collision_check_texture))
@ -914,17 +914,17 @@ void Sprite::update()
void Sprite::render_subsection(SDL_Renderer* renderer, SDL_Texture* texture, const Box& subsection, const Box& box)
{
bottom_save = std::round(subsection.get_bottom());
bottom_save = std::round(subsection.bottom());
subsection_int_rect = SDL_Rect(subsection);
subsection_int_rect.y += bottom_save - (subsection_int_rect.y + subsection_int_rect.h);
subsection_destination = subsection_int_rect;
subsection_destination.x += box.get_left();
subsection_destination.y += box.get_top();
subsection_destination.x += box.left();
subsection_destination.y += box.top();
if (get_scale() != 1)
{
unscaled_subsection = subsection;
unscaled_subsection.set_nw(unscaled_subsection.get_nw() / get_scale());
unscaled_subsection.set_size(unscaled_subsection.get_size() / get_scale());
unscaled_subsection.nw(unscaled_subsection.nw() / get_scale());
unscaled_subsection.size(unscaled_subsection.size() / get_scale());
subsection_int_rect = unscaled_subsection;
}
SDL_RenderCopy(renderer, texture, &subsection_int_rect, &subsection_destination);

2
src/Sprite.hpp
View File

@ -143,7 +143,7 @@ struct Sprite : Node
void render_subsection(SDL_Renderer*, SDL_Texture*, const Box&, const Box&);
void set_to_leave_memory_allocated();
void set_to_deallocate_memory();
virtual std::string get_class_name() const { return "Sprite"; }
virtual std::string class_name() const { return "Sprite"; }
~Sprite() { unload(); }
};

41
src/extension.cpp
View File

@ -73,14 +73,14 @@ std::vector<std::vector<Box>> sfw::get_blinds_boxes(glm::vec2 size, float step,
float inflate_per_frame = blind_height * step;
std::vector<std::vector<Box>> frames;
float bottom_save;
while (blinds[0].get_h() < blind_height)
while (blinds[0].height() < blind_height)
{
frames.push_back({});
for (Box& blind : blinds)
{
bottom_save = blind.get_bottom();
bottom_save = blind.bottom();
blind.expand({0, inflate_per_frame});
blind.set_bottom(bottom_save);
blind.bottom(bottom_save);
frames.back().push_back(blind);
}
}
@ -114,8 +114,8 @@ void sfw::populate_pixel_2d_array(
{
Uint32 format = SDL_PIXELFORMAT_RGBA32;
int bytes_per_pixel = SDL_BYTESPERPIXEL(format);
int bytes_per_row = bytes_per_pixel * region.get_w();
int bytes_total = bytes_per_row * region.get_h();
int bytes_per_row = bytes_per_pixel * region.width();
int bytes_total = bytes_per_row * region.height();
Uint8* source = new Uint8[bytes_total];
SDL_Rect int_rect = region;
if (SDL_RenderReadPixels(renderer, &int_rect, format, source, bytes_per_row) < 0)
@ -124,16 +124,16 @@ void sfw::populate_pixel_2d_array(
}
else
{
pixels.reserve(region.get_w());
for (int x = 0; x < region.get_w(); x++)
pixels.reserve(region.width());
for (int x = 0; x < region.width(); x++)
{
std::vector<SDL_Color> column;
pixels.push_back(column);
pixels[x].reserve(region.get_h());
pixels[x].reserve(region.height());
}
for (int y = 0, ii = 0; y < region.get_h(); y++)
for (int y = 0, ii = 0; y < region.height(); y++)
{
for (int x = 0; x < region.get_w(); x++)
for (int x = 0; x < region.width(); x++)
{
pixels[x][y] = {source[ii++], source[ii++], source[ii++], source[ii++]};
}
@ -236,11 +236,11 @@ void sfw::fill_texture(SDL_Renderer* renderer, SDL_Texture* texture, SDL_Texture
}
else
{
for (int x = 0; x < texture_box.get_w(); x += tile_box.get_w())
for (int x = 0; x < texture_box.width(); x += tile_box.width())
{
for (int y = 0; y < texture_box.get_h(); y += tile_box.get_h())
for (int y = 0; y < texture_box.height(); y += tile_box.height())
{
draw_rect = {(float) x, (float) y, tile_box.get_w(), tile_box.get_h()};
draw_rect = {(float) x, (float) y, tile_box.width(), tile_box.height()};
SDL_RenderCopyF(renderer, tile, nullptr, &draw_rect);
}
}
@ -328,7 +328,7 @@ SDL_Texture* sfw::get_hue_shifted_texture(SDL_Renderer* renderer, SDL_Texture* b
SDL_Texture* sfw::duplicate_texture(SDL_Renderer* renderer, SDL_Texture* base)
{
Box box = get_texture_box(base);
return duplicate_texture(renderer, base, box.get_size());
return duplicate_texture(renderer, base, box.size());
}
SDL_Texture* sfw::duplicate_texture(SDL_Renderer* renderer, SDL_Texture* base, const glm::vec2& size)
@ -424,7 +424,7 @@ SDL_Texture* sfw::get_pixel_scaled_texture(SDL_Renderer* renderer, SDL_Texture*
print_sdl_error("could not set render target to remapped texture");
return nullptr;
}
glm::ivec2 size = get_texture_box(base).get_size();
glm::ivec2 size = get_texture_box(base).size();
Uint32 format = SDL_PIXELFORMAT_RGBA32;
int bytes_per_pixel, bytes_per_row, bytes_total;
Uint32 *src, *dst, *src_begin, *dst_begin;
@ -516,11 +516,11 @@ SDL_Texture* sfw::get_pixel_scaled_texture(SDL_Renderer* renderer, SDL_Texture*
delete[] src_begin;
}
SDL_Texture* scaled = SDL_CreateTexture(renderer, format, SDL_TEXTUREACCESS_TARGET, size.x, size.y);
if (scaled == NULL)
if (scaled == nullptr)
{
print_sdl_error("could not create scaled texture");
}
if (SDL_UpdateTexture(scaled, NULL, dst_begin, bytes_per_row * 2) < 0)
if (SDL_UpdateTexture(scaled, nullptr, dst_begin, bytes_per_row * 2) < 0)
{
print_sdl_error("could not copy pixels to scaled texture");
}
@ -565,8 +565,7 @@ SDL_Surface* sfw::get_surface_from_pixels(Pixels& pixels)
return nullptr;
}
fs::path sfw::get_next_file_name(
fs::path directory, int zfill, std::string prefix, std::string extension)
fs::path sfw::get_next_file_name(fs::path directory, int zfill, std::string prefix, std::string extension)
{
std::stringstream file_pattern;
file_pattern << prefix << "([0-9]+)" << extension;
@ -649,11 +648,11 @@ int lineColor(SDL_Renderer* renderer, const Segment& segment, const Color& color
{
if (thickness == 1)
{
return lineColor(renderer, segment.start.x, segment.start.y, segment.end.x, segment.end.y, color);
return lineColor(renderer, segment.start().x, segment.start().y, segment.end().x, segment.end().y, color);
}
else
{
return thickLineColor(renderer, segment.start.x, segment.start.y, segment.end.x, segment.end.y, thickness, color);
return thickLineColor(renderer, segment.start().x, segment.start().y, segment.end().x, segment.end().y, thickness, color);
}
}

1
src/extension.hpp
View File

@ -40,6 +40,7 @@ namespace sfw
glm::vec2 point_on_circle(float, float = 1.0f);
void points_on_circle(std::vector<glm::vec2>&, int, float = 1.0f, const glm::vec2& = {0, 0}, float = 0.0f);
std::vector<glm::vec2> points_on_circle(int, float = 1.0f, const glm::vec2& = {0, 0}, float = 0.0f);
glm::vec2 map_rectangle_xy_to_circle(const glm::vec2&, float = 1.0f, const glm::vec2& = {0, 0});
Box get_texture_box(SDL_Texture*);
glm::vec2 fit_and_preserve_aspect(const glm::vec2&, const glm::vec2&);
std::vector<std::vector<Box>> get_blinds_boxes(glm::vec2, float = 0.05f, int = 4);