zemu 0.1.0

data/src/external/Z/API/Z/classes/mathematics/geometry/euclidean/Box.hpp

@@ -0,0 +1,219 @@
+/* Z Kit - classes/mathematics/geometry/euclidean/Box.hpp
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| Kit
+Copyright (C) 2006-2018 Manuel Sainz de Baranda y Goñi.
+Released under the terms of the GNU Lesser General Public License v3. */
+
+#ifndef _Z_classes_mathematics_geometry_euclidean_Box_HPP_
+#define _Z_classes_mathematics_geometry_euclidean_Box_HPP_
+
+#include <Z/classes/base/Value3D.hpp>
+#include <Z/types/mathematics.h>
+
+
+#define Z_IMPLEMENTATION_COMMON									\
+												\
+typedef typename ZTypeFixedSigned(ZBox, T) Base;						\
+Value3D<T> point, size;										\
+												\
+Z_INLINE Box() Z_DEFAULTED({})									\
+												\
+												\
+Z_CT(CPP11) Box(const Value3D<T> &point, const Value3D<T> &size)				\
+: point(point), size(size) {}									\
+												\
+												\
+Z_CT(CPP11) Box(const Value3D<T> &point, T size_x, T size_y, T size_z)				\
+: point(point), size(size_x, size_y, size_z) {}							\
+												\
+												\
+Z_CT(CPP11) Box(const Value3D<T> &point, T size_xyz)						\
+: point(point), size(size_xyz) {}								\
+												\
+												\
+Z_CT(CPP11) Box(T point_x, T point_y, T point_z, const Value3D<T> &size)			\
+: point(point_x, point_y, point_z), size(size) {}						\
+												\
+												\
+Z_CT(CPP11) Box(T point_x, T point_y, T point_z, T size_x, T size_y, T size_z)			\
+: point(point_x, point_y, point_z), size(size_x, size_y, size_z) {}				\
+												\
+												\
+Z_CT(CPP11) Box(T point_x, T point_y, T point_z, T size_xyz)					\
+: point(point_x, point_y, point_z), size(size_xyz) {}						\
+												\
+												\
+Z_CT(CPP11) Box(T point_xyz, const Value3D<T> &size)						\
+: point(point_xyz), size(size) {}								\
+												\
+												\
+Z_CT(CPP11) Box(const Value3D<T> &size)								\
+: point(T(0)), size(size) {}									\
+												\
+												\
+Z_CT(CPP11) Box(T size_x, T size_y, T size_z)							\
+: point(T(0)), size(size_x, size_y, size_z) {}							\
+												\
+												\
+Z_CT(CPP11) Box(T size_xyz)									\
+: point(T(0)), size(size_xyz) {}								\
+												\
+												\
+static Z_CT(CPP14) Box from_vertices(const Value3D<T> &a, const Value3D<T> &b)			\
+	{											\
+	Value3D<T> minimum = a.minimum(b);							\
+												\
+	return Box(minimum, a.maximum(b) - minimum);						\
+	}											\
+												\
+												\
+Z_CT(CPP11) operator Boolean() const {return point || size;}					\
+Z_INLINE    operator Base&  () const {return *((Base *)this);}					\
+												\
+												\
+Z_CT(CPP11) Boolean operator ==(const Box &rhs) const						\
+	{return point == rhs.point && size == rhs.size;}					\
+												\
+												\
+Z_CT(CPP11) Boolean operator !=(const Box &rhs) const						\
+	{return point != rhs.point || size != rhs.size;}					\
+												\
+												\
+/* Intersection */										\
+Z_CT(CPP14) Box operator &(const Box &rhs) const						\
+	{											\
+	T x1, x2, y1, y2, z1, z2;								\
+												\
+	return	(x1 = maximum<T>(point.x,	   rhs.point.x)) <				\
+		(x2 = minimum<T>(point.x + size.x, rhs.point.x + rhs.size.x)) &&		\
+		(y1 = maximum<T>(point.y,	   rhs.point.y)) <				\
+		(y2 = minimum<T>(point.y + size.y, rhs.point.y + rhs.size.y)) &&		\
+		(z1 = maximum<T>(point.z,	   rhs.point.z)) <				\
+		(z2 = minimum<T>(point.z + size.z, rhs.point.z + rhs.size.z))			\
+												\
+		? Box(x1, y1, z1, x2 - x1, y2 - y1, z2 - z1)					\
+		: Box(T(0));									\
+	}											\
+												\
+												\
+/* Union */											\
+Z_CT(CPP14) Box operator |(const Box &rhs) const						\
+	{											\
+	Box result;										\
+												\
+	result.point = point.minimum(rhs.point);						\
+	result.size  = (point + size).maximum(rhs.point + rhs.size) - result.point;		\
+	return result;										\
+	}											\
+												\
+												\
+Z_INLINE Box &operator &=(const Box &rhs) {return *this = *this & rhs;}				\
+Z_INLINE Box &operator |=(const Box &rhs) {return *this = *this | rhs;}				\
+												\
+Z_CT(CPP11) Box operator +(const Value3D<T> &rhs) const {return Box(point + rhs, size);}	\
+Z_CT(CPP11) Box operator -(const Value3D<T> &rhs) const {return Box(point - rhs, size);}	\
+Z_CT(CPP11) Box operator *(const Value3D<T> &rhs) const {return Box(point * rhs, size);}	\
+Z_CT(CPP11) Box operator /(const Value3D<T> &rhs) const {return Box(point / rhs, size);}	\
+												\
+Z_INLINE Box &operator +=(const Value3D<T> &rhs) {return *this = *this + rhs;}			\
+Z_INLINE Box &operator -=(const Value3D<T> &rhs) {return *this = *this - rhs;}			\
+Z_INLINE Box &operator *=(const Value3D<T> &rhs) {return *this = *this * rhs;}			\
+Z_INLINE Box &operator /=(const Value3D<T> &rhs) {return *this = *this / rhs;}			\
+												\
+Z_CT(CPP11) Box operator +(T rhs) const {return Value3D<T>(point + rhs, size);}			\
+Z_CT(CPP11) Box operator -(T rhs) const {return Value3D<T>(point - rhs, size);}			\
+Z_CT(CPP11) Box operator *(T rhs) const {return Value3D<T>(point * rhs, size);}			\
+Z_CT(CPP11) Box operator /(T rhs) const {return Value3D<T>(point / rhs, size);}			\
+												\
+Z_INLINE Box &operator +=(T rhs) {return *this = *this + rhs;}					\
+Z_INLINE Box &operator -=(T rhs) {return *this = *this - rhs;}					\
+Z_INLINE Box &operator *=(T rhs) {return *this = *this * rhs;}					\
+Z_INLINE Box &operator /=(T rhs) {return *this = *this / rhs;}					\
+												\
+												\
+Z_CT(CPP11) Value3D<T> center() const								\
+	{return point + size / T(2);}								\
+												\
+												\
+Z_CT(CPP11) Boolean contains(const Box &other) const						\
+	{											\
+	return	!other.size.has_zero() &&							\
+		other.point >= point && other.point + other.size <= point + size;		\
+	}											\
+												\
+												\
+/*Z_CT(CPP11) Boolean contains(const AABB<T> &aabb) const					\
+	{											\
+	return	aabb.a.x != aabb.b.x && aabb.a.y != aabb.b.y && aabb.a.z != aabb.b.z &&		\
+		aabb.a >= point && aabb.b <= point + size;					\
+	}*/											\
+												\
+												\
+Z_CT(CPP11) Boolean contains(const Value3D<T> &point) const					\
+	{return point >= this->point && point < this->point + this->size;}			\
+												\
+												\
+Z_CT(CPP11) Boolean intersects(const Box &other) const						\
+	{											\
+	return	!size.has_zero() && !other.size.has_zero() &&					\
+		other.point + other.size > point && other.point < point + size;			\
+	}											\
+												\
+												\
+Z_CT(CPP11) Boolean is_zero() const								\
+	{return point.is_zero() && size.is_zero();}						\
+												\
+												\
+Z_INLINE Box &correct()										\
+	{											\
+	if (size.x < T(0)) point.x -= (size.x = -size.x);					\
+	if (size.y < T(0)) point.y -= (size.y = -size.y);					\
+	if (size.z < T(0)) point.z -= (size.z = -size.z);					\
+	return *this;										\
+	}											\
+												\
+												\
+Z_INLINE void swap(Box &other)									\
+	{Zeta::swap<Base>((Base *)this, (Base *)&other);}					\
+};}
+
+
+namespace Zeta {
+	template <class T, UInt T_number_set = Type<T>::number_set> struct Box {};
+
+
+	template <class T> struct Box<T, Z_NUMBER_SET_Z> {
+		Z_IMPLEMENTATION_COMMON
+	};
+
+
+	template <class T> struct Box<T, Z_NUMBER_SET_R> {
+		Z_IMPLEMENTATION_COMMON
+
+
+		Z_CT(CPP11) Value3D<T> absolute_point_to_unit(const Value3D<T> &point) const
+			{return (point - this->point) / this->size;}
+
+
+		/*Z_CT(CPP11) Boolean contains(const Sphere<T> &sphere) const
+			{
+			return	sphere.radius != T(0)		      &&
+				sphere.point - sphere.radius >= point &&
+				sphere.point + sphere.radius <= point + size;
+			}*/
+
+
+		/*Z_CT(CPP11) Sphere<T> inner_sphere() const
+			{return Sphere<T>(center(), size.inner_minimum() / T(2));}*/
+
+
+		Z_CT(CPP11) Value3D<T> unit_point_to_absolute(const Value3D<T> &point) const
+			{return point * this->size + this->point;}
+	};
+}
+
+
+#undef Z_IMPLEMENTATION_COMMON
+
+#endif // _Z_classes_mathematics_geometry_euclidean_Box_HPP_

data/src/external/Z/API/Z/classes/mathematics/geometry/euclidean/Circle.hpp

@@ -0,0 +1,80 @@
+/* Z Kit - classes/mathematics/geometry/euclidean/Rectangle.hpp
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| Kit
+Copyright (C) 2006-2018 Manuel Sainz de Baranda y Goñi.
+Released under the terms of the GNU Lesser General Public License v3. */
+
+#ifndef _Z_classes_mathematics_geometry_euclidean_Rectangle_HPP_
+#define _Z_classes_mathematics_geometry_euclidean_Rectangle_HPP_
+
+#include <Z/classes/base/Value2D.hpp>
+#include <Z/types/mathematics.h>
+
+
+namespace Zeta {template <class T> struct Circle {
+
+	typedef typename ZTypeFixedReal(ZCircle, T) Base;
+
+	Value2D<T> point;
+	T radius;
+
+
+	Z_INLINE Circle() Z_DEFAULTED({})
+
+	Z_CT(CPP11) Circle(const Value2D<T> &point, T radius) : point(point), radius(radius) {}
+	Z_CT(CPP11) Circle(T x, T y, T radius)		      : point(x, y),  radius(radius) {}
+
+	Z_INLINE Circle(const Base &circle) {(*(Base *)this) = circle;}
+
+
+	Z_CT(CPP11) Boolean operator ==(const Circle &circle) const
+		{return point.x == circle.point.x && point.y == circle.point.y && radius == circle.radius;}
+
+
+	Z_CT(CPP11) Boolean operator !=(const Circle &circle) const
+		{return point.x != circle.point.x || point.y != circle.point.y || radius != circle.radius;}
+
+
+
+
+Z_INLINE ZAABR##Type z_circle_##type##_inner_aabr(ZCircle##Type object)				\
+	{											\
+	z##type half_size = object.radius / _(Z_SQUARE_ROOT_2);					\
+												\
+	return z_aabr_##type									\
+		(object.point.x - half_size, object.point.y - half_size,			\
+		 object.point.x + half_size, object.point.x + half_size);			\
+	}											\
+												\
+												\
+Z_INLINE ZRectangle##Type z_circle_##type##_inner_rectangle(ZCircle##Type object)		\
+	{											\
+	z##type half_size = object.radius / _(Z_SQUARE_ROOT_2);					\
+	z##type size = half_size * _(2.0);							\
+												\
+	return z_rectangle_##type								\
+		(object.point.x - half_size, object.point.y - half_size, size, size);		\
+	}											\
+												\
+												\
+
+
+	Z_CT(CPP11) Boolean is_zero() const
+		{return radius == T(0) && point.is_zero();}
+
+
+	Z_CT(CPP11) AABR<T> outer_aabr() const
+		{return AABR<T>(point - radius, point + radius);}
+
+
+	Z_CT(CPP11) Rectangle<T> outer_rectangle() const
+		{return Rectangle<T>(point - radius, radius * T(2));}
+
+
+	Z_INLINE void swap(Circle &circle)
+		{Zeta::swap<Base>((Base *)this, (Base *)&circle);}
+};}
+
+
+#endif // _Z_classes_mathematics_geometry_euclidean_Rectangle_HPP_

data/src/external/Z/API/Z/classes/mathematics/geometry/euclidean/Line2D.hpp

@@ -0,0 +1,93 @@
+/* Z Kit - classes/mathematics/geometry/euclidean/Line2D.hpp
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| Kit
+Copyright (C) 2006-2018 Manuel Sainz de Baranda y Goñi.
+Released under the terms of the GNU Lesser General Public License v3. */
+
+#ifndef _Z_classes_mathematics_geometry_euclidean_Line2D_HPP_
+#define _Z_classes_mathematics_geometry_euclidean_Line2D_HPP_
+
+#include <Z/classes/base/Value2D.hpp>
+#include <Z/types/mathematics.h>
+
+
+#define Z_IMPLEMENTATION_COMMON									\
+												\
+typedef typename ZTypeFixedSigned(Z2DLine, T) Base;						\
+Value2D<T> a, b;										\
+												\
+Z_INLINE Line2D() Z_DEFAULTED({})								\
+												\
+Z_CT(CPP11) Line2D(const Value2D<T> &a, const Value2D<T> &b) : a(a),	    b(b)	{}	\
+Z_CT(CPP11) Line2D(const Value2D<T> &a, T b_x, T b_y)	     : a(a),	    b(b_x, b_y) {}	\
+Z_CT(CPP11) Line2D(const Value2D<T> &a, T b_xy)		     : a(a),	    b(b_xy)     {}	\
+Z_CT(CPP11) Line2D(T a_x, T a_y, const Value2D<T> &b)	     : a(a_x, a_y), b(b)	{}	\
+Z_CT(CPP11) Line2D(T a_x, T a_y, T b_x, T b_y)		     : a(a_x, a_y), b(b_x, b_y) {}	\
+Z_CT(CPP11) Line2D(T a_xy, T b_x, T b_y)		     : a(a_xy),	    b(b_x, b_y) {}	\
+Z_CT(CPP11) Line2D(T a_xy, const Value2D<T> &b)		     : a(a_xy),	    b(b)	{}	\
+Z_CT(CPP11) Line2D(const Value2D<T> &b)			     : a(T(0)),	    b(b)	{}	\
+Z_CT(CPP11) Line2D(T b_x, T b_y)			     : a(T(0)),	    b(b_x, b_y) {}	\
+Z_CT(CPP11) Line2D(T b_xy)				     : a(T(0)),	    b(b_xy)     {}	\
+												\
+Z_INLINE Line2D(const Base &line) {(*(Base *)this) = line;}					\
+												\
+Z_CT(CPP11) Boolean operator ==(const Line2D &line) const {return a == line.a && b == line.b;}	\
+Z_CT(CPP11) Boolean operator !=(const Line2D &line) const {return a != line.a || b != line.b;}	\
+												\
+												\
+Z_CT(CPP11) Boolean is_perpendicular(const Line2D &line) const					\
+	{return ((a.b - a.a).is_perpendicular(line.b - line.a));}				\
+												\
+												\
+Z_CT(CPP11) Boolean is_zero() const								\
+	{return a.is_zero() && b.is_zero();}							\
+												\
+												\
+Z_CT(CPP11) Line2D reverse() const								\
+	{return Line2D(b, a);}									\
+												\
+												\
+Z_INLINE void swap(Line2D &line)								\
+	{Zeta::swap<Base>((Base *)this, (Base *)&line);}					\
+												\
+												\
+Z_CT(CPP11) Value2D<T> segment_center() const							\
+	{return a.middle(b);}
+
+
+namespace Zeta {
+	template <class T, UInt T_number_set = Type<T>::number_set> struct Line2D {};
+
+
+	template <class T> struct Line2D<T, Z_NUMBER_SET_Z> {
+		Z_IMPLEMENTATION_COMMON
+	};
+
+
+	template <class T> struct Line2D<T, Z_NUMBER_SET_R> {
+		Z_IMPLEMENTATION_COMMON
+
+
+		Z_CT(CPP14) Boolean segment_intersects(Line2D line_segment) const
+			{
+			Value2D<T> d  = line_segment.a - a;
+			Value2D<T> va = b - a;
+			Value2D<T> vb = line_segment.b - line_segment.a;
+			T	   c  = va.cross_product(vb);
+			T	   t  = d.cross_product(vb) / c;
+			T	   u  = d.cross_product(va) / c;
+
+			return !(t < T(0) || t > T(1) || u < T(0) || u > T(1));
+			}
+
+
+		Z_CT(CPP11) Value2D<T> segment_lerp(T alpha) const
+			{return a.lerp(b, alpha);}
+	};
+}
+
+
+#undef Z_IMPLEMENTATION_COMMON
+
+#endif // _Z_classes_mathematics_geometry_euclidean_Line2D_HPP_

data/src/external/Z/API/Z/classes/mathematics/geometry/euclidean/Line3D.hpp

@@ -0,0 +1,80 @@
+/* Z Kit - classes/mathematics/geometry/euclidean/Line3D.hpp
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| Kit
+Copyright (C) 2006-2018 Manuel Sainz de Baranda y Goñi.
+Released under the terms of the GNU Lesser General Public License v3. */
+
+#ifndef _Z_classes_mathematics_geometry_euclidean_Line3D_HPP_
+#define _Z_classes_mathematics_geometry_euclidean_Line3D_HPP_
+
+#include <Z/classes/base/Value3D.hpp>
+#include <Z/types/mathematics.h>
+
+
+#define Z_IMPLEMENTATION_COMMON									\
+												\
+typedef typename ZTypeFixedSigned(Z3DLine, T) Base;						\
+Value3D<T> a, b;										\
+												\
+Z_INLINE Line3D() Z_DEFAULTED({})								\
+												     \
+Z_CT(CPP11) Line3D(const Value3D<T> &a, const Value3D<T> &b) : a(a),		 b(b)		  {} \
+Z_CT(CPP11) Line3D(const Value3D<T> &a, T b_x, T b_y, T b_z) : a(a),		 b(b_x, b_y, b_z) {} \
+Z_CT(CPP11) Line3D(const Value3D<T> &a, T b_xyz)	     : a(a),		 b(b_xyz)	  {} \
+Z_CT(CPP11) Line3D(T a_x, T a_y, T a_z, const Value3D<T> &b) : a(a_x, a_y, a_z), b(b)		  {} \
+Z_CT(CPP11) Line3D(T a_x, T a_y, T a_z, T b_x, T b_y, T b_z) : a(a_x, a_y, a_z), b(b_x, b_y, b_z) {} \
+Z_CT(CPP11) Line3D(T a_xyz, T b_x, T b_y, T b_z)	     : a(a_xyz),	 b(b_x, b_y, b_z) {} \
+Z_CT(CPP11) Line3D(T a_xyz, const Value3D<T> &b)	     : a(a_xyz),	 b(b)		  {} \
+Z_CT(CPP11) Line3D(const Value3D<T> &b)			     : a(T(0)),		 b(b)		  {} \
+Z_CT(CPP11) Line3D(T b_x, T b_y, T b_z)			     : a(T(0)),		 b(b_x, b_y, b_z) {} \
+Z_CT(CPP11) Line3D(T b_xyz)				     : a(T(0)),		 b(b_xyz)	  {} \
+												     \
+Z_INLINE Line3D(const Base &line) {(*(Base *)this) = line;}					\
+												\
+Z_CT(CPP11) Boolean operator ==(const Line3D &line) const {return a == line.a && b == line.b;}	\
+Z_CT(CPP11) Boolean operator !=(const Line3D &line) const {return a != line.a || b != line.b;}	\
+												\
+												\
+Z_CT(CPP11) Boolean is_perpendicular(const Line3D &line) const					\
+	{return ((a.b - a.a).is_perpendicular(line.b - line.a));}				\
+												\
+												\
+Z_CT(CPP11) Boolean is_zero() const								\
+	{return a.is_zero() && b.is_zero();}							\
+												\
+												\
+Z_CT(CPP11) Line3D reverse() const								\
+	{return Line3D(b, a);}									\
+												\
+												\
+Z_INLINE void swap(Line3D &line)								\
+	{Zeta::swap<Base>((Base *)this, (Base *)&line);}					\
+												\
+												\
+Z_CT(CPP11) Value3D<T> segment_center() const							\
+	{return a.middle(b);}
+
+
+namespace Zeta {
+	template <class T, UInt T_number_set = Type<T>::number_set> struct Line3D {};
+
+
+	template <class T> struct Line3D<T, Z_NUMBER_SET_Z> {
+		Z_IMPLEMENTATION_COMMON
+	};
+
+
+	template <class T> struct Line3D<T, Z_NUMBER_SET_R> {
+		Z_IMPLEMENTATION_COMMON
+
+
+		Z_CT(CPP11) Value3D<T> segment_lerp(T alpha) const
+			{return a.lerp(b, alpha);}
+	};
+}
+
+
+#undef Z_IMPLEMENTATION_COMMON
+
+#endif // _Z_classes_mathematics_geometry_euclidean_Line3D_HPP_