point3d.hpp

Go to the documentation of this file.

/*=============================================================================
  Copyright (C) 2015-2017 DxLibEx project
  https://github.com/Nagarei/DxLibEx/

  Distributed under the Boost Software License, Version 1.0.
  (See http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef DXLE_INC_BASIC_TYPES_point3d3D_HPP_
#define DXLE_INC_BASIC_TYPES_point3d3D_HPP_
#include "dxlibex/config/no_min_max.h"
#include "dxlibex/type_traits/first_enabled.hpp"
#include "dxlibex/type_traits/enable_if.hpp"
#include "dxlibex/type_traits/is_representable.hpp"
#include "dxlibex/basic_types/use_big_type_when_one_byte_t.hpp"
#include "dxlibex/basic_types/stdint.hpp"
#include "dxlibex/basic_types/distance_result_type_t.hpp"
#include "dxlibex/basic_types/coordinate_operator_bool_helper.hpp"
#include "dxlibex/algorithm/safe_dist.hpp"
#include "dxlibex/math.hpp"
#include "dxlibex/cstdlib.hpp"
#include "dxlibex/char_constant.hpp"
//#include "dxlibex/basic_types.hpp"//DO NOT REMOVE COMMENT-OUT to avoid redefine
#include <iostream>
#include <tuple>
#include <type_traits>
#include <algorithm>
#include <cmath>
#include <limits>
#include "dxlibex/config/defines.h"

namespace dxle {
    template<typename T, enable_if_t<std::is_nothrow_move_constructible<T>::value && std::is_nothrow_move_assignable<T>::value, nullptr_t> = nullptr>
    class point3d_c final
    {
    public:
        typedef T value_type;
        value_type x, y, z;
        DXLE_CONSTEXPR point3d_c() DXLE_NOEXCEPT_IF(std::is_nothrow_constructible<value_type>::value) : x(), y(), z() {}
        DXLE_CONSTEXPR point3d_c(const value_type& x_, const value_type& y_, const value_type& z_) DXLE_NOEXCEPT_IF((std::is_nothrow_copy_constructible<value_type>::value)) : x(x_), y(y_), z(z_) {}
        DXLE_CONSTEXPR point3d_c(value_type&& x_, value_type&& y_, value_type&& z_) DXLE_NOEXCEPT_OR_NOTHROW : x(std::move(x_)), y(std::move(y_)), z(std::move(z_)) {}

        //copy constructor
        DXLE_CONSTEXPR point3d_c(const point3d_c<value_type>& o) DXLE_NOEXCEPT_IF((std::is_nothrow_copy_constructible<value_type>::value)) : x(o.x), y(o.y), z(o.z) {}
        //move constructor
        DXLE_CONSTEXPR point3d_c(point3d_c<value_type>&& o) DXLE_NOEXCEPT_OR_NOTHROW : x(std::move(o.x)), y(std::move(o.y)), z(std::move(o.z)) {}
        //copy assignment operator
        point3d_c& operator=(const point3d_c<value_type>& r) DXLE_NOEXCEPT_IF((std::is_nothrow_copy_assignable<value_type>::value))
        {
            this->x = r.x;
            this->y = r.y;
            this->z = r.z;
            return *this;
        }
        //move assignment operator
        point3d_c& operator=(point3d_c<value_type>&& r) DXLE_NOEXCEPT_OR_NOTHROW
        {
            this->x = std::move(r.x);
            this->y = std::move(r.y);
            this->z = std::move(r.z);
            return *this;
        }
        DXLE_CONSTEXPR explicit operator bool() 
            const DXLE_NOEXCEPT_IF_EXPR((dxle::detail::operator_bool_helper(std::declval<value_type>(), std::declval<value_type>(), std::declval<value_type>())))
        {
            return dxle::detail::operator_bool_helper(this->x, this->y, this->z);
        }
        template<typename Tp2_> DXLE_CONSTEXPR explicit operator point3d_c<Tp2_>() const DXLE_NOEXCEPT_OR_NOTHROW
        {
            return{ static_cast<Tp2_>(this->x), static_cast<Tp2_>(this->y), static_cast<Tp2_>(this->z) };
        }
        template<typename Tp2_> explicit operator std::tuple<Tp2_, Tp2_, Tp2_>() const DXLE_NOEXCEPT_IF_EXPR(static_cast<Tp2_>(std::declval<value_type>()))
        {
            return std::forward_as_tuple(static_cast<Tp2_>(this->x), static_cast<Tp2_>(this->y), static_cast<Tp2_>(this->z));
        }
    };
    //convert from std::tuple

    template<typename T> point3d_c<T> make_point3d_c(const std::tuple<T, T, T>& p) DXLE_NOEXCEPT_IF(std::is_nothrow_copy_constructible<T>::value)
    {
        return { std::get<0>(p),  std::get<1>(p), std::get<2>(p) };
    }
    template<typename T> point3d_c<T> make_point3d_c(std::tuple<T, T, T>&& p) DXLE_NOEXCEPT_OR_NOTHROW
    {
        return point3d_c<T>(std::move(std::get<0>(p)), std::move(std::get<1>(p)), std::move(std::get<2>(p)));
    }

    //ostream operator
    namespace detail {
        template<typename CharType, typename point3dType>
        void ostream_operator_helper(std::basic_ostream<CharType>& os, const CharType* str, const point3d_c<point3dType>& p)
        {
            using use_big_type_when_one_byte_p = use_big_type_when_one_byte_t<point3dType>;
            os << static_cast<use_big_type_when_one_byte_p>(p.x) << str << static_cast<use_big_type_when_one_byte_p>(p.y) << str << static_cast<use_big_type_when_one_byte_p>(p.z);
        }
        template<typename CharType, typename point3dType>
        void istream_operator_helper(std::basic_istream<CharType>& is, point3d_c<point3dType>& p)
        {
            use_big_type_when_one_byte_t<point3dType> x, y, z;
            is >> x;
            is.ignore((std::numeric_limits<std::streamsize>::max)(), dxle::char_constant::comma<CharType>());
            is >> y;
            is.ignore((std::numeric_limits<std::streamsize>::max)(), dxle::char_constant::comma<CharType>());
            is >> z;
            p.x = static_cast<point3dType>(x); p.y = static_cast<point3dType>(y); p.z = static_cast<point3dType>(z);
        }
    }
    template<typename T> std::ostream& operator<<(std::ostream& os, const point3d_c<T>& p)
    {
        dxle::detail::ostream_operator_helper<char, T>(os, ", ", p);
        return os;
    }
    template<typename T> std::wostream& operator<<(std::wostream& os, const point3d_c<T>& p)
    {
        dxle::detail::ostream_operator_helper<wchar_t, T>(os, L", ", p);
        return os;
    }
    template<typename T> std::istream& operator>>(std::istream& is, point3d_c<T>& p)
    {
        dxle::detail::istream_operator_helper<char, T>(is, p);
        return is;
    }
    template<typename T> std::wistream& operator>>(std::wistream& is, point3d_c<T>& p)
    {
        dxle::detail::istream_operator_helper<wchar_t, T>(is, p);
        return is;
    }

    template <typename T>
    DXLE_CONSTEXPR point3d_c<T> operator -(const point3d_c<T>& r) DXLE_NOEXCEPT_IF_EXPR(-std::declval<T>())
    {
        return { -r.x, -r.y, -r.z };
    }

    template <typename T>
    DXLE_CONSTEXPR inline const point3d_c<T>& operator +(const point3d_c<T>& r) DXLE_NOEXCEPT_IF(std::is_nothrow_copy_constructible<T>::value) { return r; }

    template <typename T>
    DXLE_CONSTEXPR inline point3d_c<T>&& operator +(point3d_c<T>&& r) DXLE_NOEXCEPT_OR_NOTHROW { return std::move(r); }

    template <typename T1, typename T2, enable_if_t<is_representable<T2, T1>::value, nullptr_t> = nullptr>
    point3d_c<T1>& operator +=(point3d_c<T1>& l, const point3d_c<T2>& r) DXLE_NOEXCEPT_IF_EXPR(l.x += r.x)
    {
        l.x += r.x;
        l.y += r.y;
        l.z += r.z;
        return l;
    }

    template <typename T1, typename T2, enable_if_t<is_representable<T2, T1>::value, nullptr_t> = nullptr>
    point3d_c<T1>& operator -=(point3d_c<T1>& l, const point3d_c<T2>& r) DXLE_NOEXCEPT_IF_EXPR(l.x -= r.x)
    {
        l.x -= r.x;
        l.y -= r.y;
        l.z -= r.z;
        return l;
    }

    template <typename T1, typename T2>
    DXLE_CONSTEXPR auto operator +(const point3d_c<T1>& l, const point3d_c<T2>& r) DXLE_NOEXCEPT_IF_EXPR(l.x + r.x)
        ->point3d_c<decltype(std::declval<std::remove_cv_t<T1>>() + std::declval<std::remove_cv_t<T2>>())>
    {
        return { l.x + r.x, l.y + r.y, l.z + r.z };
    }

    template <typename T1, typename T2>
    DXLE_CONSTEXPR auto operator -(const point3d_c<T1>& l, const point3d_c<T2>& r) DXLE_NOEXCEPT_IF_EXPR(l.x - r.x)
        ->point3d_c<decltype(std::declval<std::remove_cv_t<T1>>() - std::declval<std::remove_cv_t<T2>>())>
    {
        return { l.x - r.x, l.y - r.y, l.z - r.z };
    }

    template <typename T1, typename T2>
    DXLE_CONSTEXPR auto operator *(const point3d_c<T1>& l, T2 r) DXLE_NOEXCEPT_IF_EXPR(l.x * r)
        ->point3d_c<decltype(std::declval<std::remove_cv_t<T1>>() * std::declval<std::remove_cv_t<T2>>())>
    {
        return { l.x * r, l.y * r, l.z * r };
    }

    template <typename T1, typename T2>
    DXLE_CONSTEXPR auto operator *(T1 l, const point3d_c<T2>& r) DXLE_NOEXCEPT_IF_EXPR(l + r.x)
        ->point3d_c<decltype(std::declval<std::remove_cv_t<T1>>() * std::declval<std::remove_cv_t<T2>>())>
    {
        return { l * r.x, l * r.y, l * r.z };
    }

    template <typename T1, typename T2, enable_if_t<is_representable<T2, T1>::value, nullptr_t> = nullptr>
    point3d_c<T1>& operator *=(point3d_c<T1>& l, T2 r) DXLE_NOEXCEPT_IF_EXPR(l.x *= r)
    {
        l.x *= r;
        l.y *= r;
        l.z *= r;
        return l;
    }

    template <typename T1, typename T2>
    DXLE_CONSTEXPR auto operator /(const point3d_c<T1>& l, T2 r) DXLE_NOEXCEPT_IF_EXPR(l.x / r)
        ->point3d_c<decltype(std::declval<std::remove_cv_t<T1>>() - std::declval<std::remove_cv_t<T2>>())>
    {
        return { l.x / r, l.y / r, l.z / r};
    }

    template <typename T1, typename T2, enable_if_t<is_representable<T2, T1>::value, nullptr_t> = nullptr>
    point3d_c<T1>& operator /=(point3d_c<T1>& l, T2 r) DXLE_NOEXCEPT_IF_EXPR(l.x /= r)
    {
        l.x /= r;
        l.y /= r;
        l.z /= r;
        return l;
    }

    template <typename T>
    DXLE_CONSTEXPR bool operator !=(const point3d_c<T>& l, const point3d_c<T>& r) DXLE_NOEXCEPT_IF_EXPR(l.x != r.x)
    {
        return (l.x != r.x) || (l.y != r.y) || (l.z != r.z);
    }

    template <typename T>
    DXLE_CONSTEXPR bool operator !=(const point3d_c<T>& p, nullptr_t) DXLE_NOEXCEPT_IF_EXPR(static_cast<bool>(p))
    {
        return !static_cast<bool>(p);
    }

    template <typename T>
    DXLE_CONSTEXPR bool operator !=(nullptr_t, const point3d_c<T>& p) DXLE_NOEXCEPT_IF_EXPR(static_cast<bool>(p))
    {
        return !static_cast<bool>(p);
    }

    template <typename T, enable_if_t<std::is_arithmetic<T>::value, nullptr_t> = nullptr>
    DXLE_CONSTEXPR bool operator ==(const point3d_c<T>& l, const point3d_c<T>& r) DXLE_NOEXCEPT_IF_EXPR(l.x != r.x) { return !(l != r); }

    template <typename T>
    DXLE_CONSTEXPR bool operator ==(const point3d_c<T>& p, nullptr_t) DXLE_NOEXCEPT_IF_EXPR(static_cast<bool>(p))
    {
        return !static_cast<bool>(p);
    }

    template <typename T>
    DXLE_CONSTEXPR bool operator ==(nullptr_t, const point3d_c<T>& p) DXLE_NOEXCEPT_IF_EXPR(static_cast<bool>(p))
    {
        return !static_cast<bool>(p);
    }

    template<typename T>
    DXLE_CONSTEXPR point3d_c<T> abs(const point3d_c<T>& o) DXLE_NOEXCEPT_IF_EXPR(abs(o.x)) { return{ abs(o.x), abs(o.y), abs(o.z) }; }

    template<typename T1, typename T2>
    DXLE_CONSTEXPR auto dot(const point3d_c<T1>& p1, const point3d_c<T2>& p2) DXLE_NOEXCEPT_IF_EXPR(p1.x * p2.x + p1.y * p2.y + p1.z * p2.z)
        -> decltype(std::declval<std::remove_cv_t<T1>>() * std::declval<std::remove_cv_t<T2>>())
    {
        return p1.x * p2.x + p1.y * p2.y + p1.z * p2.z;
    }

    template<typename T1, typename T2>
    DXLE_CONSTEXPR auto cross(const point3d_c<T1>& p1, const point3d_c<T2>& p2) DXLE_NOEXCEPT_IF_EXPR(std::declval<T1>() * std::declval<T2>() - std::declval<T1>() * std::declval<T2>())
        ->point3d_c<decltype(std::declval<std::remove_cv_t<T1>>() * std::declval<std::remove_cv_t<T2>>())>
    {
        //a＝（a1,a2,a3）、 b＝（b1,b2,b3）としたとき、（a2b3-a3b2, a3b1-a1b3, a1b2-a2b1）
        return { p1.y * p2.z - p1.z * p2.y, p1.z * p2.x - p1.x * p2.z, p1.x * p2.y - p1.y * p2.x };
    }

    template<typename T1, typename T2> 
    distance_result_type_t<T1, T2> distance(const point3d_c<T1>& p1, const point3d_c<T2>& p2)
        DXLE_NOEXCEPT_IF_EXPR(hypot(safe_dist(std::declval<T1>(), std::declval<T2>()), safe_dist(std::declval<T1>(), std::declval<T2>())))
    {
        return hypot(safe_dist(p1.x, p2.x), hypot(safe_dist(p1.y, p2.y), safe_dist(p1.z, p2.z)));
    }
    typedef point3d_c<int> point3di;
    typedef point3d_c<std::uint8_t> point3du8i;
    typedef point3d_c<std::int8_t> point3d8i;
    typedef point3d_c<double> point3dd;
    typedef point3d_c<float> point3df;
};
#endif //DXLE_INC_BASIC_TYPES_point3d3D_HPP_