Added Vector2i and Rect2i to sfwl.

compile_linux_sfwl.sh

@@ -12,6 +12,9 @@ ccache g++ -Wall -D_REENTRANT -g -Isfwl -c sfwl/core/safe_refcount.cpp -o sfwl/c
 ccache g++ -Wall -D_REENTRANT -g -Isfwl -c sfwl/core/ustring.cpp -o sfwl/core/ustring.o
 ccache g++ -Wall -D_REENTRANT -g -Isfwl -c sfwl/core/string_name.cpp -o sfwl/core/string_name.o
 
+ccache g++ -Wall -D_REENTRANT -g -Isfw -c sfwl/core/rect2i.cpp -o sfwl/core/rect2i.o
+ccache g++ -Wall -D_REENTRANT -g -Isfw -c sfwl/core/vector2i.cpp -o sfwl/core/vector2i.o
+
 ccache g++ -Wall -D_REENTRANT -g -Isfwl -c sfwl/core/file_access.cpp -o sfwl/core/file_access.o
 ccache g++ -Wall -D_REENTRANT -g -Isfwl -c sfwl/core/dir_access.cpp -o sfwl/core/dir_access.o
 
@@ -43,7 +46,7 @@ ccache g++ -Wall -D_REENTRANT -g -Isfwl -c sfwl/main.cpp -o sfwl/main.o
 
 # You might need to add -lpthread and/or -latomic depending on your compiler version  (add it near -lX11)
 
-ccache g++ -Wall -D_REENTRANT -g  sfwl/core/color.o \
+ccache g++ -Wall -D_REENTRANT -g  sfwl/core/color.o sfwl/core/rect2i.o sfwl/core/vector2i.o \
                         sfwl/core/logger.o sfwl/core/math_funcs.o \
                         sfwl/core/memory.o sfwl/core/pcg.o sfwl/core/random_pcg.o \
                         sfwl/core/safe_refcount.o \
@@ -59,3 +62,4 @@ ccache g++ -Wall -D_REENTRANT -g  sfwl/core/color.o \
                         sfwl/object/resource.o \
                         sfwl/main.o \
                         -o sfwl_app 
+

sfwl/core/rect2i.cpp

@@ -0,0 +1,12 @@
+/*************************************************************************/
+/*  rect2i.cpp                                                           */
+/*  From https://github.com/Relintai/pandemonium_engine (MIT)            */
+/*************************************************************************/
+
+//--STRIP
+#include "core/transform_2d.h" // Includes rect2.h but Rect2 needs Transform2D
+//--STRIP
+
+Rect2i::operator String() const {
+	return "[P: " + position.operator String() + ", S: " + size + "]";
+}

sfwl/core/rect2i.h

@@ -0,0 +1,238 @@
+//--STRIP
+#ifndef RECT2I_H
+#define RECT2I_H
+//--STRIP
+
+/*************************************************************************/
+/*  rect2i.h                                                             */
+/*  From https://github.com/Relintai/pandemonium_engine (MIT)            */
+/*************************************************************************/
+
+//--STRIP
+#include "core/vector2i.h" // also includes math_funcs and ustring
+#include "core/rect2.h"
+//--STRIP
+
+struct _NO_DISCARD_CLASS_ Rect2i {
+	Point2i position;
+	Size2i size;
+
+	const Point2i &get_position() const { return position; }
+	void set_position(const Point2i &p_position) { position = p_position; }
+	const Size2i &get_size() const { return size; }
+	void set_size(const Size2i &p_size) { size = p_size; }
+
+	int get_area() const { return size.width * size.height; }
+
+	_FORCE_INLINE_ Vector2i get_center() const { return position + (size / 2); }
+
+	inline bool intersects(const Rect2i &p_rect) const {
+		if (position.x > (p_rect.position.x + p_rect.size.width)) {
+			return false;
+		}
+		if ((position.x + size.width) < p_rect.position.x) {
+			return false;
+		}
+		if (position.y > (p_rect.position.y + p_rect.size.height)) {
+			return false;
+		}
+		if ((position.y + size.height) < p_rect.position.y) {
+			return false;
+		}
+
+		return true;
+	}
+
+	inline bool encloses(const Rect2i &p_rect) const {
+		return (p_rect.position.x >= position.x) && (p_rect.position.y >= position.y) &&
+				((p_rect.position.x + p_rect.size.x) < (position.x + size.x)) &&
+				((p_rect.position.y + p_rect.size.y) < (position.y + size.y));
+	}
+
+	_FORCE_INLINE_ bool has_no_area() const {
+		return (size.x <= 0 || size.y <= 0);
+	}
+
+	inline Rect2i clip(const Rect2i &p_rect) const { /// return a clipped rect
+
+		Rect2i new_rect = p_rect;
+
+		if (!intersects(new_rect)) {
+			return Rect2i();
+		}
+
+		new_rect.position.x = MAX(p_rect.position.x, position.x);
+		new_rect.position.y = MAX(p_rect.position.y, position.y);
+
+		Point2 p_rect_end = p_rect.position + p_rect.size;
+		Point2 end = position + size;
+
+		new_rect.size.x = (int)(MIN(p_rect_end.x, end.x) - new_rect.position.x);
+		new_rect.size.y = (int)(MIN(p_rect_end.y, end.y) - new_rect.position.y);
+
+		return new_rect;
+	}
+
+	// Returns the instersection between two Rect2is or an empty Rect2i if there is no intersection
+	inline Rect2i intersection(const Rect2i &p_rect) const {
+		Rect2i new_rect = p_rect;
+
+		if (!intersects(new_rect)) {
+			return Rect2i();
+		}
+
+		new_rect.position.x = MAX(p_rect.position.x, position.x);
+		new_rect.position.y = MAX(p_rect.position.y, position.y);
+
+		Point2i p_rect_end = p_rect.position + p_rect.size;
+		Point2i end = position + size;
+
+		new_rect.size.x = MIN(p_rect_end.x, end.x) - new_rect.position.x;
+		new_rect.size.y = MIN(p_rect_end.y, end.y) - new_rect.position.y;
+
+		return new_rect;
+	}
+
+	inline Rect2i merge(const Rect2i &p_rect) const { ///< return a merged rect
+
+		Rect2i new_rect;
+
+		new_rect.position.x = MIN(p_rect.position.x, position.x);
+		new_rect.position.y = MIN(p_rect.position.y, position.y);
+
+		new_rect.size.x = MAX(p_rect.position.x + p_rect.size.x, position.x + size.x);
+		new_rect.size.y = MAX(p_rect.position.y + p_rect.size.y, position.y + size.y);
+
+		new_rect.size = new_rect.size - new_rect.position; //make relative again
+
+		return new_rect;
+	}
+
+	bool has_point(const Point2i &p_point) const {
+		if (p_point.x < position.x) {
+			return false;
+		}
+		if (p_point.y < position.y) {
+			return false;
+		}
+
+		if (p_point.x >= (position.x + size.x)) {
+			return false;
+		}
+		if (p_point.y >= (position.y + size.y)) {
+			return false;
+		}
+
+		return true;
+	}
+
+	bool operator==(const Rect2i &p_rect) const { return position == p_rect.position && size == p_rect.size; }
+	bool operator!=(const Rect2i &p_rect) const { return position != p_rect.position || size != p_rect.size; }
+
+	Rect2i grow(int p_by) const {
+		Rect2i g = *this;
+		g.position.x -= p_by;
+		g.position.y -= p_by;
+		g.size.width += p_by * 2;
+		g.size.height += p_by * 2;
+		return g;
+	}
+
+	void grow_by(int p_by) {
+		position.x -= p_by;
+		position.y -= p_by;
+		size.width += p_by * 2;
+		size.height += p_by * 2;
+	}
+
+	inline Rect2i grow_margin(Margin p_margin, int p_amount) const {
+		Rect2i g = *this;
+		g = g.grow_individual((MARGIN_LEFT == p_margin) ? p_amount : 0,
+				(MARGIN_TOP == p_margin) ? p_amount : 0,
+				(MARGIN_RIGHT == p_margin) ? p_amount : 0,
+				(MARGIN_BOTTOM == p_margin) ? p_amount : 0);
+		return g;
+	}
+
+	inline Rect2i grow_side(Side p_side, int p_amount) const {
+		Rect2i g = *this;
+		g = g.grow_individual((SIDE_LEFT == p_side) ? p_amount : 0,
+				(SIDE_TOP == p_side) ? p_amount : 0,
+				(SIDE_RIGHT == p_side) ? p_amount : 0,
+				(SIDE_BOTTOM == p_side) ? p_amount : 0);
+		return g;
+	}
+
+	inline Rect2i grow_individual(int p_left, int p_top, int p_right, int p_bottom) const {
+		Rect2i g = *this;
+		g.position.x -= p_left;
+		g.position.y -= p_top;
+		g.size.width += p_left + p_right;
+		g.size.height += p_top + p_bottom;
+
+		return g;
+	}
+
+	_FORCE_INLINE_ Rect2i expand(const Vector2i &p_vector) const {
+		Rect2i r = *this;
+		r.expand_to(p_vector);
+		return r;
+	}
+
+	inline void expand_to(const Point2i &p_vector) {
+		Point2i begin = position;
+		Point2i end = position + size;
+
+		if (p_vector.x < begin.x) {
+			begin.x = p_vector.x;
+		}
+		if (p_vector.y < begin.y) {
+			begin.y = p_vector.y;
+		}
+
+		if (p_vector.x > end.x) {
+			end.x = p_vector.x;
+		}
+		if (p_vector.y > end.y) {
+			end.y = p_vector.y;
+		}
+
+		position = begin;
+		size = end - begin;
+	}
+
+	_FORCE_INLINE_ Rect2i abs() const {
+		return Rect2i(Point2i(position.x + MIN(size.x, 0), position.y + MIN(size.y, 0)), size.abs());
+	}
+
+	_FORCE_INLINE_ void set_end(const Vector2i &p_end) {
+		size = p_end - position;
+	}
+
+	_FORCE_INLINE_ Vector2i get_end() const {
+		return position + size;
+	}
+
+	Rect2 to_rect2() const { return Rect2(position, size); }
+
+	operator String() const;
+	operator Rect2() const { return Rect2(position, size); }
+
+	Rect2i(const Rect2 &p_r2) :
+			position(p_r2.position),
+			size(p_r2.size) {
+	}
+	Rect2i() {}
+	Rect2i(int p_x, int p_y, int p_width, int p_height) :
+			position(Point2(p_x, p_y)),
+			size(Size2(p_width, p_height)) {
+	}
+	Rect2i(const Point2 &p_pos, const Size2 &p_size) :
+			position(p_pos),
+			size(p_size) {
+	}
+};
+
+//--STRIP
+#endif // RECT2_H
+//--STRIP

sfwl/core/vector2i.cpp

@@ -0,0 +1,79 @@
+/*************************************************************************/
+/*  vector2i.cpp                                                         */
+/*  From https://github.com/Relintai/pandemonium_engine (MIT)            */
+/*************************************************************************/
+
+//--STRIP
+#include "core/vector2i.h"
+
+#include "core/ustring.h"
+//--STRIP
+
+Vector2i Vector2i::clamp(const Vector2i &p_min, const Vector2i &p_max) const {
+	return Vector2i(
+			CLAMP(x, p_min.x, p_max.x),
+			CLAMP(y, p_min.y, p_max.y));
+}
+
+int64_t Vector2i::length_squared() const {
+	return x * (int64_t)x + y * (int64_t)y;
+}
+
+double Vector2i::length() const {
+	return Math::sqrt((double)length_squared());
+}
+
+Vector2i Vector2i::operator+(const Vector2i &p_v) const {
+	return Vector2i(x + p_v.x, y + p_v.y);
+}
+void Vector2i::operator+=(const Vector2i &p_v) {
+	x += p_v.x;
+	y += p_v.y;
+}
+Vector2i Vector2i::operator-(const Vector2i &p_v) const {
+	return Vector2i(x - p_v.x, y - p_v.y);
+}
+void Vector2i::operator-=(const Vector2i &p_v) {
+	x -= p_v.x;
+	y -= p_v.y;
+}
+
+Vector2i Vector2i::operator*(const Vector2i &p_v1) const {
+	return Vector2i(x * p_v1.x, y * p_v1.y);
+};
+
+Vector2i Vector2i::operator*(const int &rvalue) const {
+	return Vector2i(x * rvalue, y * rvalue);
+};
+void Vector2i::operator*=(const int &rvalue) {
+	x *= rvalue;
+	y *= rvalue;
+};
+
+Vector2i Vector2i::operator/(const Vector2i &p_v1) const {
+	return Vector2i(x / p_v1.x, y / p_v1.y);
+};
+
+Vector2i Vector2i::operator/(const int &rvalue) const {
+	return Vector2i(x / rvalue, y / rvalue);
+};
+
+void Vector2i::operator/=(const int &rvalue) {
+	x /= rvalue;
+	y /= rvalue;
+};
+
+Vector2i Vector2i::operator-() const {
+	return Vector2i(-x, -y);
+}
+
+bool Vector2i::operator==(const Vector2i &p_vec2) const {
+	return x == p_vec2.x && y == p_vec2.y;
+}
+bool Vector2i::operator!=(const Vector2i &p_vec2) const {
+	return x != p_vec2.x || y != p_vec2.y;
+}
+
+Vector2i::operator String() const {
+	return "(" + itos(x) + ", " + itos(y) + ")";
+}

sfwl/core/vector2i.h

@@ -0,0 +1,147 @@
+//--STRIP
+#ifndef VECTOR2I_H
+#define VECTOR2I_H
+//--STRIP
+
+/*************************************************************************/
+/*  vector2i.h                                                           */
+/*  From https://github.com/Relintai/pandemonium_engine (MIT)            */
+/*************************************************************************/
+
+//--STRIP
+#include "core/error_macros.h"
+#include "core/math_funcs.h"
+
+#include "core/vector2.h"
+//--STRIP
+
+class String;
+
+struct _NO_DISCARD_CLASS_ Vector2i {
+	enum Axis {
+		AXIS_X,
+		AXIS_Y,
+	};
+
+	union {
+		struct {
+			union {
+				int x;
+				int width;
+			};
+			union {
+				int y;
+				int height;
+			};
+		};
+
+		int coord[2];
+	};
+
+	_FORCE_INLINE_ int &operator[](int p_idx) {
+		DEV_ASSERT((unsigned int)p_idx < 2);
+		return coord[p_idx];
+	}
+	_FORCE_INLINE_ const int &operator[](int p_idx) const {
+		DEV_ASSERT((unsigned int)p_idx < 2);
+		return coord[p_idx];
+	}
+
+	_FORCE_INLINE_ void set_all(int p_value) {
+		x = y = p_value;
+	}
+
+	_FORCE_INLINE_ int min_axis() const {
+		return x < y ? 0 : 1;
+	}
+
+	_FORCE_INLINE_ int max_axis() const {
+		return x < y ? 1 : 0;
+	}
+
+	Vector2i min(const Vector2i &p_vector2i) const {
+		return Vector2i(MIN(x, p_vector2i.x), MIN(y, p_vector2i.y));
+	}
+
+	Vector2i max(const Vector2i &p_vector2i) const {
+		return Vector2i(MAX(x, p_vector2i.x), MAX(y, p_vector2i.y));
+	}
+
+	_FORCE_INLINE_ static Vector2i linear_interpolate(const Vector2i &p_a, const Vector2i &p_b, real_t p_weight);
+	_FORCE_INLINE_ Vector2i linear_interpolate(const Vector2i &p_to, real_t p_weight) const;
+
+	Vector2i operator+(const Vector2i &p_v) const;
+	void operator+=(const Vector2i &p_v);
+	Vector2i operator-(const Vector2i &p_v) const;
+	void operator-=(const Vector2i &p_v);
+	Vector2i operator*(const Vector2i &p_v1) const;
+
+	Vector2i operator*(const int &rvalue) const;
+	void operator*=(const int &rvalue);
+
+	Vector2i operator/(const Vector2i &p_v1) const;
+
+	Vector2i operator/(const int &rvalue) const;
+
+	void operator/=(const int &rvalue);
+
+	Vector2i operator-() const;
+	bool operator<(const Vector2i &p_vec2) const { return (x == p_vec2.x) ? (y < p_vec2.y) : (x < p_vec2.x); }
+	bool operator>(const Vector2i &p_vec2) const { return (x == p_vec2.x) ? (y > p_vec2.y) : (x > p_vec2.x); }
+	bool operator<=(const Vector2 &p_vec2) const { return x == p_vec2.x ? (y <= p_vec2.y) : (x < p_vec2.x); }
+	bool operator>=(const Vector2 &p_vec2) const { return x == p_vec2.x ? (y >= p_vec2.y) : (x > p_vec2.x); }
+
+	bool operator==(const Vector2i &p_vec2) const;
+	bool operator!=(const Vector2i &p_vec2) const;
+
+	int64_t length_squared() const;
+	double length() const;
+
+	real_t aspect() const { return width / (real_t)height; }
+	Vector2i sign() const { return Vector2i(SGN(x), SGN(y)); }
+	Vector2i abs() const { return Vector2i(ABS(x), ABS(y)); }
+	Vector2i clamp(const Vector2i &p_min, const Vector2i &p_max) const;
+
+	Vector2 to_vector2() const { return Vector2(x, y); }
+
+	operator String() const;
+	operator Vector2() const { return Vector2(x, y); }
+
+	inline Vector2i(const Vector2 &p_vec2) {
+		x = (int)p_vec2.x;
+		y = (int)p_vec2.y;
+	}
+	inline Vector2i(int p_x, int p_y) {
+		x = p_x;
+		y = p_y;
+	}
+	inline Vector2i() {
+		x = 0;
+		y = 0;
+	}
+};
+
+Vector2i Vector2i::linear_interpolate(const Vector2i &p_a, const Vector2i &p_b, real_t p_weight) {
+	Vector2i res = p_a;
+
+	res.x += (p_weight * (p_b.x - p_a.x));
+	res.y += (p_weight * (p_b.y - p_a.y));
+
+	return res;
+}
+
+Vector2i Vector2i::linear_interpolate(const Vector2i &p_to, real_t p_weight) const {
+	Vector2 res = *this;
+
+	res.x += (p_weight * (p_to.x - x));
+	res.y += (p_weight * (p_to.y - y));
+
+	return res;
+}
+
+typedef Vector2i Size2i;
+typedef Vector2i Point2i;
+
+//--STRIP
+#endif // VECTOR2_H
+//--STRIP

tools/merger/sfwl/sfwl_core.cpp.inl

@@ -95,6 +95,15 @@
 //#include "core/math_funcs.h"
 //--STRIP
 {{FILE:sfwl/core/color.cpp}}
+//--STRIP
+//#include "core/vector2i.h"
+//#include "core/ustring.h"
+//--STRIP
+{{FILE:sfwl/core/vector2i.cpp}}
+//--STRIP
+//#include "core/transform_2d.h" // Includes rect2.h but Rect2 needs Transform2D
+//--STRIP
+{{FILE:sfwl/core/rect2i.cpp}}
 
 //--STRIP
 //#include "core/pcg.h"

tools/merger/sfwl/sfwl_core.h.inl

@@ -211,6 +211,17 @@
 //#include "core/ustring.h"
 //--STRIP
 {{FILE:sfwl/core/color.h}}
+//--STRIP
+//#include "core/error_macros.h"
+//#include "core/math_funcs.h"
+//#include "core/vector2.h"
+//--STRIP
+{{FILE:sfwl/core/vector2i.h}}
+//--STRIP
+//#include "core/vector2i.h" // also includes math_funcs and ustring
+//#include "core/rect2.h"
+//--STRIP
+{{FILE:sfwl/core/rect2i.h}}
 
 //--STRIP
 //Needs ustring.h

tools/merger/sfwl/sfwl_full.cpp.inl

@@ -95,6 +95,15 @@
 //#include "core/math_funcs.h"
 //--STRIP
 {{FILE:sfwl/core/color.cpp}}
+//--STRIP
+//#include "core/vector2i.h"
+//#include "core/ustring.h"
+//--STRIP
+{{FILE:sfwl/core/vector2i.cpp}}
+//--STRIP
+//#include "core/transform_2d.h" // Includes rect2.h but Rect2 needs Transform2D
+//--STRIP
+{{FILE:sfwl/core/rect2i.cpp}}
 
 //--STRIP
 //#include "core/pcg.h"

tools/merger/sfwl/sfwl_full.h.inl

@@ -211,6 +211,17 @@
 //#include "core/ustring.h"
 //--STRIP
 {{FILE:sfwl/core/color.h}}
+//--STRIP
+//#include "core/error_macros.h"
+//#include "core/math_funcs.h"
+//#include "core/vector2.h"
+//--STRIP
+{{FILE:sfwl/core/vector2i.h}}
+//--STRIP
+//#include "core/vector2i.h" // also includes math_funcs and ustring
+//#include "core/rect2.h"
+//--STRIP
+{{FILE:sfwl/core/rect2i.h}}
 
 //--STRIP
 //Needs ustring.h