Vertex.hpp

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Base
File: Vertex
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <NDEVR/Vector.h>
 
namespace NDEVR
{
    template<uint01 t_dims, class t_type, class t_vector_type = Vector<t_dims, t_type>>
    class Vertex : public t_vector_type
    {
    public:
        constexpr Vertex()
            : t_vector_type()
        {}
        constexpr explicit Vertex(const t_type& scaler)
            : t_vector_type(scaler)
        {}
        constexpr Vertex(const t_vector_type& vector)
            : t_vector_type(vector)
        {}
        constexpr Vertex(const Vertex<t_dims, t_type, t_vector_type>& vector)
            : t_vector_type(vector)
        {}
        constexpr Vertex(const t_type x, const t_type y)
            : t_vector_type(x, y)
        {}
        constexpr Vertex(t_type x, t_type y, t_type z)
            : t_vector_type(x, y, z)
        {}
        constexpr Vertex(const t_type x, const t_type y, const t_type z, const t_type w)
            : t_vector_type(x, y, z, w)
        {}
        constexpr explicit Vertex(const t_type(&vector)[t_dims])
            : t_vector_type(vector)
        {}
        constexpr Vertex(const Vector<getMax(t_dims - 1, 0), t_type>& vector, const t_type postfix)
            : t_vector_type(vector, postfix)
        {}
        constexpr Vertex(const Vector<getMax(t_dims - 2, 0), t_type>& vector, const t_type postfix_a, const t_type postfix_b)
            : t_vector_type(vector, postfix_a, postfix_b)
        {}
        constexpr Vertex(const t_type prefix, const Vector<t_dims - 1, t_type>& vector)
            : t_vector_type(prefix, vector)
        {}
        template<uint01 t_new_dim, class t_new_type, class t_new_vector = Vector<t_new_dim, t_new_type>>
        constexpr Vertex<t_new_dim, t_new_type, t_new_vector> as() const
        {
            return Vertex<t_new_dim, t_new_type, t_new_vector>(t_vector_type::template as<t_new_dim, t_new_type>());
        }
        template<class t_new_type, class t_new_vector = Vector<t_dims, t_new_type>>
        constexpr Vertex<t_dims, t_new_type, t_new_vector> as() const
        {
            return Vertex<t_dims, t_new_type, t_new_vector>(t_vector_type::template as<t_dims, t_new_type>());
        }
        template<uint01 t_new_dim, class t_new_type, class t_new_vector = Vector<t_new_dim, t_new_type>>
        constexpr Vertex<t_new_dim, t_new_type, t_new_vector> as(t_new_type extra_fill_value) const
        {
            return Vertex<t_new_dim, t_new_type, t_new_vector>(t_vector_type::template as<t_new_dim, t_new_type>(extra_fill_value));
        }
        constexpr Vertex scale(const t_vector_type& scale, const Vertex<t_dims, t_type>& center) const
        {
            return ((*this - center) * scale) + center;
        }
        constexpr Vertex scale(const t_type scale, const Vertex<t_dims, t_type>& center) const
        {
            return ((*this - center) * scale) + center;
        }
        constexpr const Vertex& center() const
        {
            return *this;
        }
        constexpr Vertex<t_dims, t_type, t_vector_type>& operator=(const t_type& scaler)
        {
            t_vector_type::operator=(scaler);
            return *this;
        }
        constexpr Vertex<t_dims, t_type, t_vector_type>& operator=(const t_vector_type& vector)
        {
            t_vector_type::operator=(vector);
            return *this;
        }
        constexpr Vertex<t_dims, t_type, t_vector_type>& operator=(const Vertex<t_dims, t_type, t_vector_type>& vector)
        {
            t_vector_type::operator=(vector);
            return *this;
        }
    };
    template<uint01 t_dims, class t_type, class t_base>
    constexpr Vertex<t_dims, t_type, t_base> getMax(const Vertex<t_dims, t_type, t_base>& v1, const Vertex<t_dims, t_type, t_base >& v2)
    {
        Vertex<t_dims, t_type, t_base> vec;
        for (uint01 dim = 0; dim < t_dims; dim++)
        {
            vec[dim] = getMax(v1[dim], v2[dim]);
        }
        return vec;
    }
    template<uint01 t_dims, class t_type, class t_base>
    constexpr Vertex<t_dims, t_type, t_base> getMin(const Vertex<t_dims, t_type, t_base>& v1, const Vertex<t_dims, t_type, t_base>& v2)
    {
        Vertex<t_dims, t_type, t_base> vec;
        for (uint01 dim = 0; dim < t_dims; dim++)
        {
            vec[dim] = getMin(v1[dim], v2[dim]);
        }
        return vec;
    }
    template<uint01 t_dims, class t_type, class t_vector_type>
    struct Constant<Vertex<t_dims, t_type, t_vector_type>>
    {
        constexpr const static Vertex<t_dims, t_type, t_vector_type> Invalid{ Constant<t_type>::Invalid };
        constexpr const static Vertex<t_dims, t_type, t_vector_type> Min{ Constant<t_type>::Min };
        constexpr const static Vertex<t_dims, t_type, t_vector_type> Max{ Constant<t_type>::Max };
    };
    template<uint01 t_dims, class t_type, class t_vector_type>
    static constexpr bool IsInvalid(const Vertex<t_dims, t_type, t_vector_type>& value)
    {
        for (uint01 dim = 0; dim < t_dims; ++dim)
        {
            if (IsInvalid(value[dim]))
                return true;
        }
        return false;
    }
    template<uint01 t_dims, class t_type, class t_vector_type>
    static constexpr bool IsValid(const Vertex<t_dims, t_type, t_vector_type>& value)
    {
        for (uint01 dim = 0; dim < t_dims; ++dim)
        {
            if (IsInvalid(value[dim]))
                return false;
        }
        return true;
    }
    template<uint01 t_dims, class t_type, class t_vector_type = Vector<t_dims, t_type>>
    class Ray : public t_vector_type
    {
    public:
        constexpr Ray()
            : t_vector_type()
        {}
        constexpr explicit Ray(const t_type& scaler)
            : t_vector_type(scaler)
        {}
        constexpr Ray(const t_vector_type& vector)
            : t_vector_type(vector)
        {}
        constexpr Ray(const Ray<t_dims, t_type, t_vector_type>& vector)
            : t_vector_type(vector)
        {}
        constexpr Ray(const t_type x, const t_type y)
            : t_vector_type(x, y)
        {}
        constexpr Ray(t_type x, t_type y, t_type z)
            : t_vector_type(x, y, z)
        {}
        constexpr Ray(const t_type x, const t_type y, const t_type z, const t_type w)
            : t_vector_type(x, y, z, w)
        {}
        constexpr explicit Ray(const t_type(&vector)[t_dims])
            : t_vector_type(vector)
        {}
        constexpr Ray(const Vector<getMax(t_dims - 1, 0), t_type>& vector, const t_type postfix)
            : t_vector_type(vector, postfix)
        {}
        constexpr Ray(const Vector<getMax(t_dims - 2, 0), t_type>& vector, const t_type postfix_a, const t_type postfix_b)
            : t_vector_type(vector, postfix_a, postfix_b)
        {}
        constexpr Ray(const t_type prefix, const Vector<t_dims - 1, t_type>& vector)
            : t_vector_type(prefix, vector)
        {}
        template<uint01 t_new_dim, class t_new_type, class t_new_vector = Vector<t_new_dim, t_new_type>>
        constexpr Ray<t_new_dim, t_new_type, t_new_vector> as(t_new_type extra_fill_value = 0) const
        {
            return Ray<t_new_dim, t_new_type, t_new_vector>(t_vector_type::template as<t_new_dim, t_new_type>(extra_fill_value));
        }
        template<class t_new_type, class t_new_vector = Vector<t_dims, t_new_type>>
        constexpr Ray<t_dims, t_new_type, t_new_vector> as() const
        {
            return Ray<t_dims, t_new_type, t_new_vector>(t_vector_type::template as<t_new_type>());
        }
        constexpr Ray scale(const t_vector_type& scale) const
        {
            return (*this * scale);
        }
        constexpr Ray scale(const t_type scale) const
        {
            return (*this * scale);
        }
        constexpr Ray<t_dims, t_type, t_vector_type>& operator=(const t_type& scaler)
        {
            t_vector_type::operator=(scaler);
            return *this;
        }
        constexpr Ray<t_dims, t_type, t_vector_type>& operator=(const t_vector_type& vector)
        {
            t_vector_type::operator=(vector);
            return *this;
        }
        constexpr Ray<t_dims, t_type, t_vector_type>& operator=(const Ray<t_dims, t_type, t_vector_type>& vector)
        {
            t_vector_type::operator=(vector);
            return *this;
        }
    };
    template<uint01 t_dims, class t_type, class t_base>
    constexpr Ray<t_dims, t_type, t_base> getMax(const Ray<t_dims, t_type, t_base>& v1, const Ray<t_dims, t_type, t_base >& v2)
    {
        Ray<t_dims, t_type, t_base> vec;
        for (uint01 dim = 0; dim < t_dims; dim++)
        {
            vec[dim] = getMax(abs(v1[dim]), abs(v2[dim]));
        }
        return vec;
    }
    template<uint01 t_dims, class t_type, class t_base>
    constexpr Ray<t_dims, t_type, t_base> getMin(const Ray<t_dims, t_type, t_base>& v1, const Ray<t_dims, t_type, t_base>& v2)
    {
        Ray<t_dims, t_type, t_base> vec;
        for (uint01 dim = 0; dim < t_dims; dim++)
        {
            vec[dim] = getMin(abs(v1[dim]), abs(v2[dim]));
        }
        return vec;
    }
    template<uint01 t_dims, class t_type, class t_vector_type>
    struct Constant<Ray<t_dims, t_type, t_vector_type>>
    {
        constexpr const static Ray<t_dims, t_type, t_vector_type> Invalid{ Constant<t_vector_type>::Invalid };
        constexpr const static Ray<t_dims, t_type, t_vector_type> Min{ 0 };
        constexpr const static Ray<t_dims, t_type, t_vector_type> Max{ Constant<t_vector_type>::Max };
    };
    template<uint01 t_dims, class t_type, class t_vector_type>
    static constexpr bool IsInvalid(const Ray<t_dims, t_type, t_vector_type>& value)
    {
        for (uint01 dim = 0; dim < t_dims; ++dim)
        {
            if (IsInvalid(value[dim]))
                return true;
        }
        return false;
    }
    template<uint01 t_dims, class t_type, class t_vector_type>
    static constexpr bool IsValid(const Ray<t_dims, t_type, t_vector_type>& value)
    {
        for (uint01 dim = 0; dim < t_dims; ++dim)
        {
            if (IsInvalid(value[dim]))
                return false;
        }
        return true;
    }
}
namespace std//Define things to allow use within std libs
{
    template <>
    struct hash<Vertex<3, fltp08>>
    {
        std::size_t operator()(const Vertex<3, fltp08>& s) const noexcept
        {
            std::size_t h = 0, g = 0;
            const uint01* bytes = reinterpret_cast<const uint01*>(&s[0]);
            for (size_t i = 0; i < 3 * sizeof(fltp08); i++)
            {
                h = (h << 4) + bytes[i];
                g = h & 0xF0000000L;
                if (g)
                    h ^= g >> 24;
                h &= ~g;
            }
            return h;
        }
    };
    template <>
    struct hash<Vertex<3, fltp04>>
    {
        std::size_t operator()(const Vertex<3, fltp04>& s) const noexcept
        {
            std::size_t h = 0, g = 0;
            const uint01* bytes = reinterpret_cast<const uint01*>(&s[0]);
            for (size_t i = 0; i < 3 * sizeof(fltp04); i++)
            {
                h = (h << 4) + bytes[i];
                g = h & 0xF0000000L;
                if (g)
                    h ^= g >> 24;
                h &= ~g;
            }
            return h;
        }
    };
};