zemu 0.1.0

data/src/external/Z/API/Z/functions/base/value.hpp

@@ -0,0 +1,112 @@
+/* Z Kit - functions/base/value.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_functions_base_value_HPP_
+#define _Z_functions_base_value_HPP_
+
+#include <Z/traits/Type.hpp>
+
+namespace Zeta {
+
+
+	// MARK: - Functions for any type
+
+
+	template <class T> static Z_INLINE void swap(void *a, void *b)
+		{
+		T t = *(T *)a;
+		*(T *)a = *(T *)b;
+		*(T *)b = t;
+		}
+
+
+	// MARK: - Functions for comparable types
+
+
+	template <class T> static Z_CT(CPP11) T maximum(T a, T b) {return a > b ? a : b;}
+	template <class T> static Z_CT(CPP11) T minimum(T a, T b) {return a < b ? a : b;}
+
+
+	template <class T> static Z_CT(CPP11) T clamp(T value, T minimum, T maximum)
+		{return Zeta::minimum(Zeta::maximum(value, minimum), maximum);}
+
+
+	// MARK: - Functions for signed types
+
+
+	template <class T> static Z_CT(CPP11) T absolute(T value)
+		{return value < T(0) ? -value : value;}
+
+
+	template <class T> static Z_CT(CPP11) T sign(T value)
+		{return value >= T(0) ? T(1) : -T(1);}
+
+
+	// MARK: - Functions for real types
+
+
+	template <class T> static Z_CT(CPP11) Boolean are_almost_equal(T a, T b)
+		{return absolute(a - b) <= Type<T>::epsilon();}
+
+
+	template <class T> static Z_CT(CPP11) T clamp_01(T value)
+		{return minimum<T>(maximum<T>(value, T(0.0)), T(1.0));}
+
+
+	template <class T> static Z_CT(CPP11) T inverse_lerp(T a, T b, T t)
+		{return (t - a) / (b - a);}
+
+
+	template <class T> static Z_CT(CPP11) Boolean is_almost_zero(T value)
+		{return absolute<T>(value) <= Type<T>::epsilon();}
+
+
+	template <class T> static Z_CT(CPP11) Boolean is_finite(T value)
+		{return value == value && value != Type<T>::infinity() && value != -Type<T>::infinity();}
+
+
+	template <class T> static Z_CT(CPP11) Boolean is_infinity(T value)
+		{return value == Type<T>::infinity() || value == -Type<T>::infinity();}
+
+
+	template <class T> static Z_CT(CPP11) Boolean is_nan(T value)
+		{return !(value == value);}
+
+
+	template <class T> static Z_CT(CPP11) T lerp(T a, T b, T t)
+		{return a + t * (b - a);}
+
+
+	template <class T> static Z_CT(CPP11) T sign_or_zero(T value)
+		{
+		return absolute<T>(value) <= Type<T>::epsilon()
+			? T(0.0)
+			: sign<T>(value);
+		}
+
+
+	template <class T> static Z_CT(CPP14) T smootherstep(T a, T b, T t)
+		{
+		if (t <= a) return T(0.0);
+		if (t >= b) return T(1.0);
+		t = (t - a) / (b - a);
+		return t * t * t * (t * (t * T(6.0) - T(15.0)) + T(10.0));
+		}
+
+
+	template <class T> static Z_CT(CPP14) T smoothstep(T a, T b, T t)
+		{
+		if (t <= a) return T(0.0);
+		if (t >= b) return T(1.0);
+		t = (t - a) / (b - a);
+		return t * t * (T(3.0) - T(2.0) * t);
+		}
+
+
+}
+
+#endif // _Z_functions_base_value_HPP_

data/src/external/Z/API/Z/functions/buffering/ZRingBuffer.h

@@ -0,0 +1,85 @@
+/* Z Kit - functioms/buffering/ZRingBuffer.h
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| 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_functions_buffering_ZRingBuffer_H_
+#define _Z_functions_buffering_ZRingBuffer_H_
+
+#include <Z/types/buffering.h>
+#include <Z/functions/base/value.h>
+
+#define z_cpu_relax() asm volatile("pause\n": : :"memory")
+
+
+static Z_INLINE void z_ring_buffer_initialize(
+	ZRingBuffer* object,
+	void const*  buffers,
+	zusize	     buffer_size,
+	zusize	     buffer_count
+)
+	{
+	object->buffers		  = (void *)buffers;
+	object->buffer_size	  = buffer_size;
+	object->buffer_count	  = buffer_count;
+	object->production_index  = 0;
+	object->consumption_index = 0;
+	object->fill_count	  = 0;
+	}
+
+
+static Z_INLINE void *z_ring_buffer_production_buffer(ZRingBuffer const *object)
+	{
+	return object->buffer_count - object->fill_count
+		? (zuint8 *)object->buffers + object->production_index * object->buffer_size
+		: NULL;
+	}
+
+
+static Z_INLINE void *z_ring_buffer_consumption_buffer(ZRingBuffer const *object)
+	{
+	return object->fill_count
+		? (zuint8 *)object->buffers + object->consumption_index * object->buffer_size
+		: NULL;
+	}
+
+
+static Z_INLINE void *z_ring_buffer_try_produce(ZRingBuffer *object)
+	{
+	if (object->buffer_count == object->fill_count) return NULL;
+	object->production_index = (object->production_index + 1) % object->buffer_count;
+	z_type_atomic_increment_then_get(USIZE)(&object->fill_count);
+	return (zuint8 *)object->buffers + object->production_index * object->buffer_size;
+	}
+
+
+static Z_INLINE void *z_ring_buffer_try_consume(ZRingBuffer *object)
+	{
+	if (!object->fill_count) return NULL;
+	object->consumption_index = (object->consumption_index + 1) % object->buffer_count;
+	z_type_atomic_decrement_then_get(USIZE)(&object->fill_count);
+	return (zuint8 *)object->buffers + object->consumption_index * object->buffer_size;
+	}
+
+
+static Z_INLINE void *z_ring_buffer_produce(ZRingBuffer *object)
+	{
+	while (object->buffer_count == object->fill_count) z_cpu_relax();
+	object->production_index = (object->production_index + 1) % object->buffer_count;
+	z_type_atomic_increment_then_get(USIZE)(&object->fill_count);
+	return (zuint8 *)object->buffers + object->production_index * object->buffer_size;
+	}
+
+
+static Z_INLINE void *z_ring_buffer_consume(ZRingBuffer *object)
+	{
+	while (!object->fill_count) z_cpu_relax();
+	object->consumption_index = (object->consumption_index + 1) % object->buffer_count;
+	z_type_atomic_decrement_then_get(USIZE)(&object->fill_count);
+	return (zuint8 *)object->buffers + object->consumption_index * object->buffer_size;
+	}
+
+
+#endif /* _Z_functions_buffering_ZRingBuffer_H_ */

data/src/external/Z/API/Z/functions/buffering/ZTripleBuffer.h

@@ -0,0 +1,65 @@
+/* Z Kit - functioms/buffering/ZTripleBuffer.h
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| Kit
+Copyright (C) 2012 Remis.
+Copyright (C) 2014 Manuel Sainz de Baranda y Goñi.
+Released under the terms of the GNU Lesser General Public License v3. */
+
+#ifndef _Z_functions_buffering_ZTripleBuffer_H_
+#define _Z_functions_buffering_ZTripleBuffer_H_
+
+#include <Z/types/buffering.h>
+#include <Z/functions/base/value.h>
+
+
+static Z_INLINE void z_triple_buffer_initialize(
+	ZTripleBuffer* object,
+	void const*    buffers,
+	zusize	       buffer_size
+)
+	{
+	object->buffers[0] = (zuint8 *)buffers;
+	object->buffers[1] = (zuint8 *)buffers + buffer_size;
+	object->buffers[2] = (zuint8 *)buffers + buffer_size * 2;
+	object->flags	   = 6;
+	}
+
+
+static Z_INLINE void *z_triple_buffer_production_buffer(ZTripleBuffer const *object)
+	{return object->buffers[(object->flags & 48) >> 4];}
+
+
+static Z_INLINE void *z_triple_buffer_consumption_buffer(ZTripleBuffer const *object)
+	{return object->buffers[object->flags & 3];}
+
+
+static Z_INLINE void *z_triple_buffer_produce(ZTripleBuffer *object)
+	{
+	zuint8 flags, new_flags;
+
+	do	{
+		flags = object->flags;
+		new_flags = 64 | ((flags & 12) << 2) | ((flags & 48) >> 2) | (flags & 3);
+		}
+	while (!z_uint8_atomic_set_if_equal(&object->flags, flags, new_flags));
+
+	return object->buffers[(new_flags & 48) >> 4];
+	}
+
+
+static Z_INLINE void *z_triple_buffer_consume(ZTripleBuffer *object)
+	{
+	zuint8 flags, new_flags;
+
+	do	{
+		if (!((flags = object->flags) & 64)) return NULL;
+		new_flags = (flags & 48) | ((flags & 3) << 2) | ((flags & 12) >> 2);
+		}
+	while (!z_uint8_atomic_set_if_equal(&object->flags, flags, new_flags));
+
+	return object->buffers[new_flags & 3];;
+	}
+
+
+#endif /* _Z_functions_buffering_ZTripleBuffer_H_ */

data/src/external/Z/API/Z/functions/mathematics/geometry/euclidean/Z2DLine.h

@@ -0,0 +1,179 @@
+/* Z Kit - functions/mathematics/geometry/euclidean/Z2DLine.h
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| 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_functions_mathematics_geometry_euclidean_Z2DLine_H_
+#define _Z_functions_mathematics_geometry_euclidean_Z2DLine_H_
+
+#include <Z/functions/mathematics/geometry/euclidean/constructors.h>
+#include <Z/functions/base/Z2D.h>
+
+
+/* MARK: - Common implementation */
+
+
+#define Z_IMPLEMENTATION_COMMON(Type, type)							\
+												\
+static Z_INLINE											\
+zboolean z_2d_line_##type##_are_equal(Z2DLine##Type a, Z2DLine##Type b)				\
+	{return z_2d_##type##_are_equal(a.a, b.a) && z_2d_##type##_are_equal(a.b, b.b);}	\
+												\
+												\
+static Z_INLINE											\
+zboolean z_2d_line_##type##_are_perpendicular(Z2DLine##Type a, Z2DLine##Type b)			\
+	{											\
+	return z_2d_##type##_are_perpendicular							\
+		(z_2d_##type##_subtract(a.b, a.a), z_2d_##type##_subtract(b.b, b.a));		\
+	}											\
+												\
+												\
+static Z_INLINE											\
+zboolean z_2d_line_##type##_is_zero(Z2DLine##Type object)					\
+	{return z_2d_##type##_is_zero(object.a) && z_2d_##type##_is_zero(object.b);}		\
+												\
+												\
+static Z_INLINE											\
+Z2DLine##Type z_2d_line_##type##_reverse(Z2DLine##Type object)					\
+	{return z_2d_line_##type(object.b.x, object.b.y, object.a.x, object.a.y);}		\
+												\
+												\
+static Z_INLINE											\
+void z_2d_line_##type##_swap(Z2DLine##Type *a, Z2DLine##Type *b)				\
+	{											\
+	Z2DLine##Type t = *a;									\
+												\
+	*a = *b; *b = t;									\
+	}											\
+												\
+												\
+static Z_INLINE											\
+ZAABR##Type z_2d_line_segment_##type##_aabr(Z2DLine##Type object)				\
+	{											\
+	return z_aabr_##type									\
+		(z_##type##_minimum(object.a.x, object.b.x),					\
+		 z_##type##_minimum(object.a.y, object.b.y),					\
+		 z_##type##_maximum(object.a.x, object.b.x),					\
+		 z_##type##_maximum(object.a.y, object.b.y));					\
+	}											\
+												\
+												\
+static Z_INLINE											\
+Z2D##Type z_2d_line_segment_##type##_center(Z2DLine##Type object)				\
+	{return z_2d_##type##_middle(object.a, object.b);}
+
+
+#define z_2d_line_type_are_equal(	 TYPE) Z_INSERT_##TYPE##_fixed_type(z_2d_line_,		_are_equal	  )
+#define z_2d_line_type_are_perpendicular(TYPE) Z_INSERT_##TYPE##_fixed_type(z_2d_line_,		_are_perpendicular)
+#define z_2d_line_type_is_zero(		 TYPE) Z_INSERT_##TYPE##_fixed_type(z_2d_line_,		_is_zero	  )
+#define z_2d_line_type_reverse(		 TYPE) Z_INSERT_##TYPE##_fixed_type(z_2d_line_,		_reverse	  )
+#define z_2d_line_type_swap(		 TYPE) Z_INSERT_##TYPE##_fixed_type(z_2d_line_,		_swap		  )
+#define z_2d_line_segment_aabr(		 TYPE) Z_INSERT_##TYPE##_fixed_type(z_2d_line_segment_, _aabr		  )
+#define z_2d_line_segment_type_center(	 TYPE) Z_INSERT_##TYPE##_fixed_type(z_2d_line_segment_, _center		  )
+
+
+/* MARK: - Partial implementation for real types */
+
+
+#define Z_IMPLEMENTATION_REAL(Type, type)							\
+												\
+static Z_INLINE											\
+zboolean z_2d_line_segment_##type##_intersect(Z2DLine##Type a, Z2DLine##Type b)			\
+	{											\
+	Z2D##Type d  = z_2d_##type##_subtract(b.a, a.a);					\
+	Z2D##Type va = z_2d_##type##_subtract(a.b, a.a);					\
+	Z2D##Type vb = z_2d_##type##_subtract(b.b, b.a);					\
+	z##type	  c  = z_2d_##type##_cross_product(va, vb);					\
+	z##type	  t  = z_2d_##type##_cross_product(d, vb) / c;					\
+	z##type	  u  = z_2d_##type##_cross_product(d, va) / c;					\
+												\
+	return !(t < (z##type)0 || t > (z##type)1 || u < (z##type)0 || u > (z##type)1);		\
+	}											\
+												\
+												\
+static Z_INLINE											\
+Z2D##Type z_2d_line_segment_##type##_lerp(Z2DLine##Type object, z##type alpha)			\
+	{return z_2d_##type##_lerp(object.a, object.b, alpha);}
+
+
+#define z_2d_line_segment_type_intersect(TYPE) Z_INSERT_##TYPE##_fixed_type(z_2d_line_segment_, _intersect)
+#define z_2d_line_segment_type_lerp(	 TYPE) Z_INSERT_##TYPE##_fixed_type(z_2d_line_segment_, _lerp	  )
+
+
+/* MARK: - Implementation expansions */
+
+
+Z_IMPLEMENTATION_COMMON(SInt8,	sint8 )
+Z_IMPLEMENTATION_COMMON(SInt16, sint16)
+Z_IMPLEMENTATION_COMMON(SInt32, sint32)
+
+#ifdef Z_SINT64
+	Z_IMPLEMENTATION_COMMON(SInt64, sint64)
+#endif
+
+#ifdef Z_SINT128
+	Z_IMPLEMENTATION_COMMON(SInt128, sint128)
+#endif
+
+#ifdef Z_FLOAT16
+	Z_IMPLEMENTATION_COMMON(Float16, float16)
+	Z_IMPLEMENTATION_REAL  (Float16, float16)
+#endif
+
+#ifdef Z_FLOAT32
+	Z_IMPLEMENTATION_COMMON(Float32, float32)
+	Z_IMPLEMENTATION_REAL  (Float32, float32)
+#endif
+
+#ifdef Z_FLOAT64
+	Z_IMPLEMENTATION_COMMON(Float64, float64)
+	Z_IMPLEMENTATION_REAL  (Float64, float64)
+#endif
+
+#ifdef Z_FLOAT128
+	Z_IMPLEMENTATION_COMMON(Float128, float128)
+	Z_IMPLEMENTATION_REAL  (Float128, float128)
+#endif
+
+#ifdef Z_FLOAT80_X87
+	Z_IMPLEMENTATION_COMMON(Float80_x87, float80_x87)
+	Z_IMPLEMENTATION_REAL  (Float80_x87, float80_x87)
+#endif
+
+#ifdef Z_FLOAT96_X87
+	Z_IMPLEMENTATION_COMMON(Float96_x87, float96_x87)
+	Z_IMPLEMENTATION_REAL  (Float96_x87, float96_x87)
+#endif
+
+#ifdef Z_FLOAT128_X87
+	Z_IMPLEMENTATION_COMMON(Float128_x87, float128_x87)
+	Z_IMPLEMENTATION_REAL  (Float128_x87, float128_x87)
+#endif
+
+
+/* MARK: - Cleanup */
+
+
+#undef Z_IMPLEMENTATION_COMMON
+#undef Z_IMPLEMENTATION_REAL
+
+
+/* MARK: - Default real type definitions */
+
+
+#ifdef Z_REAL
+#	define z_2d_line_are_equal	   z_2d_line_type_are_equal	   (REAL)
+#	define z_2d_line_are_perpendicular z_2d_line_type_are_perpendicular(REAL)
+#	define z_2d_line_is_zero	   z_2d_line_type_is_zero	   (REAL)
+#	define z_2d_line_reverse	   z_2d_line_type_reverse	   (REAL)
+#	define z_2d_line_swap		   z_2d_line_type_swap		   (REAL)
+#	define z_2d_line_segment_aabr	   z_2d_line_segment_type_aabr	   (REAL)
+#	define z_2d_line_segment_center	   z_2d_line_segment_type_center   (REAL)
+#	define z_2d_line_segment_intersect z_2d_line_segment_type_intersect(REAL)
+#	define z_2d_line_segment_lerp	   z_2d_line_segment_type_lerp	   (REAL)
+#endif
+
+
+#endif /* _Z_functions_mathematics_geometry_euclidean_Z2DLine_H_ */

data/src/external/Z/API/Z/functions/mathematics/geometry/euclidean/Z3DLine.h

@@ -0,0 +1,168 @@
+/* Z Kit - functions/mathematics/geometry/euclidean/Z3DLine.h
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| 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_functions_mathematics_geometry_euclidean_Z3DLine_H_
+#define _Z_functions_mathematics_geometry_euclidean_Z3DLine_H_
+
+#include <Z/functions/mathematics/geometry/euclidean/constructors.h>
+#include <Z/functions/base/Z3D.h>
+
+
+/* MARK: - Common implementation */
+
+
+#define Z_IMPLEMENTATION_COMMON(Type, type)							\
+												\
+static Z_INLINE											\
+zboolean z_3d_line_##type##_are_equal(Z3DLine##Type a, Z3DLine##Type b)				\
+	{return z_3d_##type##_are_equal(a.a, b.a) && z_3d_##type##_are_equal(a.b, b.b);}	\
+												\
+												\
+static Z_INLINE											\
+zboolean z_3d_line_##type##_are_perpendicular(Z3DLine##Type a, Z3DLine##Type b)			\
+	{											\
+	return z_3d_##type##_are_perpendicular							\
+		(z_3d_##type##_subtract(a.b, a.a), z_3d_##type##_subtract(b.b, b.a));		\
+	}											\
+												\
+												\
+static Z_INLINE											\
+zboolean z_3d_line_##type##_is_zero(Z3DLine##Type object)					\
+	{return z_3d_##type##_is_zero(object.a) && z_3d_##type##_is_zero(object.b);}		\
+												\
+												\
+static Z_INLINE											\
+Z3DLine##Type z_3d_line_##type##_reverse(Z3DLine##Type object)					\
+	{											\
+	return z_3d_line_##type									\
+		(object.b.x, object.b.y, object.b.z, object.a.x, object.a.y, object.a.z);	\
+	}											\
+												\
+												\
+static Z_INLINE											\
+void z_3d_line_##type##_swap(Z3DLine##Type *a, Z3DLine##Type *b)				\
+	{											\
+	Z3DLine##Type t = *a;									\
+												\
+	*a = *b; *b = t;									\
+	}											\
+												\
+												\
+static Z_INLINE											\
+ZAABB##Type z_3d_line_segment_##type##_aabb(Z3DLine##Type object)				\
+	{											\
+	return z_aabb_##type									\
+		(z_##type##_minimum(object.a.x, object.b.x),					\
+		 z_##type##_minimum(object.a.y, object.b.y),					\
+		 z_##type##_minimum(object.a.z, object.b.z),					\
+		 z_##type##_maximum(object.a.x, object.b.x),					\
+		 z_##type##_maximum(object.a.y, object.b.y),					\
+		 z_##type##_maximum(object.a.z, object.b.z));					\
+	}											\
+												\
+												\
+static Z_INLINE											\
+Z3D##Type z_3d_line_segment_##type##_center(Z3DLine##Type object)				\
+	{return z_3d_##type##_middle(object.a, object.b);}
+
+
+#define z_3d_line_type_are_equal(	 TYPE) Z_INSERT_##TYPE##_fixed_type(z_3d_line_,		_are_equal	  )
+#define z_3d_line_type_are_perpendicular(TYPE) Z_INSERT_##TYPE##_fixed_type(z_3d_line_,		_are_perpendicular)
+#define z_3d_line_type_is_zero(		 TYPE) Z_INSERT_##TYPE##_fixed_type(z_3d_line_,		_is_zero	  )
+#define z_3d_line_type_reverse(		 TYPE) Z_INSERT_##TYPE##_fixed_type(z_3d_line_,		_reverse	  )
+#define z_3d_line_type_swap(		 TYPE) Z_INSERT_##TYPE##_fixed_type(z_3d_line_,		_swap		  )
+#define z_2d_line_segment_aabb(		 TYPE) Z_INSERT_##TYPE##_fixed_type(z_2d_line_segment_, _aabb		  )
+#define z_3d_line_segment_type_center(	 TYPE) Z_INSERT_##TYPE##_fixed_type(z_3d_line_segment_, _center		  )
+
+
+/* MARK: - Partial implementation for real types */
+
+
+#define Z_IMPLEMENTATION_REAL(Type, type)							\
+												\
+static Z_INLINE											\
+Z3D##Type z_3d_line_segment_##type##_lerp(Z3DLine##Type object, z##type alpha)			\
+	{return z_3d_##type##_lerp(object.a, object.b, alpha);}
+
+
+#define z_3d_line_segment_type_lerp(TYPE) Z_INSERT_##TYPE##_fixed_type(z_3d_line_segment_, _lerp)
+
+
+/* MARK: - Implementation expansions */
+
+
+Z_IMPLEMENTATION_COMMON(SInt8,	sint8 )
+Z_IMPLEMENTATION_COMMON(SInt16, sint16)
+Z_IMPLEMENTATION_COMMON(SInt32, sint32)
+
+#ifdef Z_SINT64
+	Z_IMPLEMENTATION_COMMON(SInt64, sint64)
+#endif
+
+#ifdef Z_SINT128
+	Z_IMPLEMENTATION_COMMON(SInt128, sint128)
+#endif
+
+#ifdef Z_FLOAT16
+	Z_IMPLEMENTATION_COMMON(Float16, float16)
+	Z_IMPLEMENTATION_REAL  (Float16, float16)
+#endif
+
+#ifdef Z_FLOAT32
+	Z_IMPLEMENTATION_COMMON(Float32, float32)
+	Z_IMPLEMENTATION_REAL  (Float32, float32)
+#endif
+
+#ifdef Z_FLOAT64
+	Z_IMPLEMENTATION_COMMON(Float64, float64)
+	Z_IMPLEMENTATION_REAL  (Float64, float64)
+#endif
+
+#ifdef Z_FLOAT128
+	Z_IMPLEMENTATION_COMMON(Float128, float128)
+	Z_IMPLEMENTATION_REAL  (Float128, float128)
+#endif
+
+#ifdef Z_FLOAT80_X87
+	Z_IMPLEMENTATION_COMMON(Float80_x87, float80_x87)
+	Z_IMPLEMENTATION_REAL  (Float80_x87, float80_x87)
+#endif
+
+#ifdef Z_FLOAT96_X87
+	Z_IMPLEMENTATION_COMMON(Float96_x87, float96_x87)
+	Z_IMPLEMENTATION_REAL  (Float96_x87, float96_x87)
+#endif
+
+#ifdef Z_FLOAT128_X87
+	Z_IMPLEMENTATION_COMMON(Float128_x87, float128_x87)
+	Z_IMPLEMENTATION_REAL  (Float128_x87, float128_x87)
+#endif
+
+
+/* MARK: - Cleanup */
+
+
+#undef Z_IMPLEMENTATION_COMMON
+#undef Z_IMPLEMENTATION_REAL
+
+
+/* MARK: - Default real type definitions */
+
+
+#ifdef Z_REAL
+#	define z_3d_line_are_equal	   z_3d_line_type_are_equal	   (REAL)
+#	define z_3d_line_are_perpendicular z_3d_line_type_are_perpendicular(REAL)
+#	define z_3d_line_is_zero	   z_3d_line_type_is_zero	   (REAL)
+#	define z_3d_line_reverse	   z_3d_line_type_reverse	   (REAL)
+#	define z_3d_line_swap		   z_3d_line_type_swap		   (REAL)
+#	define z_2d_line_segment_aabb	   z_2d_line_segment_type_aabb	   (REAL)
+#	define z_3d_line_segment_center	   z_3d_line_segment_type_center   (REAL)
+#	define z_3d_line_segment_lerp	   z_3d_line_segment_type_lerp	   (REAL)
+#endif
+
+
+#endif /* _Z_functions_mathematics_geometry_euclidean_Z3DLine_H_ */