Point3D.h

Go to the documentation of this file.

#pragma once
 
#include <iostream>
#include <cmath>
 
#include "../Types.h"
#include "Point.h"
 
namespace Gorgon { namespace Geometry {
    
    template<class T_>
    class basic_Point3D {
    public:
        typedef T_ BaseType;
 
        basic_Point3D() { }
 
        basic_Point3D(const T_ &X, const T_ &Y, const T_ &Z) : X(X), Y(Y), Z(Z) { }
 
        basic_Point3D(const basic_Point<T_> &point, const T_ &Z = T_()) : X(point.X), Y(point.Y), Z(Z) { }
        
        Float operator *(const basic_Point3D &other) const {
            return X*other.X + Y*other.Y + Z*other.Z;
        }
        
        basic_Point3D operator *(Float val) const {
            return {X*val, Y*val, Z*val};
        }
       
        basic_Point3D operator /(Float val) const {
            return {X/val, Y/val, Z/val};
        }
        
        basic_Point3D operator +(const basic_Point3D &other) const {
            return {X+other.X, Y+other.Y, Z+other.Z};
        }
        
        basic_Point3D operator -(const basic_Point3D &other) const {
            return {X-other.X, Y-other.Y, Z-other.Z};
        }
        
        basic_Point3D Normalize() const {
            auto dist = Distance();
            
            return {X/dist, Y/dist, Z/dist};
        }
        
        Float Distance() const {
            return (Float)std::sqrt(X*X+Y*Y+Z*Z);
        }
       
        Float ManhattanDistance() const {
            return (Float)(std::abs(X)+std::abs(Y)+std::abs(Z));
        }
 
        basic_Point3D CrossProduct(const basic_Point3D &other) const {
            return {Y*other.Z - Z*other.Y, Z*other.X - X*other.Z, X*other.Y - Y*other.X};
        }
        
        union {
            struct {
                T_ X;
                T_ Y;
                T_ Z;
            };
            
            T_ Vector[3];
        };
    };
 
    template <class T_>
    std::ostream &operator << (std::ostream &out, const basic_Point3D<T_> &point) {
        out<<"("<<point.X<<", "<<point.Y<<", "<<point.Z<<")";
 
        return out;
    }
    
    using Point3D = basic_Point3D<Float>;
    
} }