FLPoint4.h

#pragma once
 
#include "FLPoint3.h"

namespace FLImaging
{
    namespace Foundation
    {
        template<typename Ty>
        class FL_EXPORT CFLGeometry3DQuaternion;
 
        template<typename Ty>
        class FL_EXPORT CMatrix;

        template<typename Ty>
        class FL_EXPORT CFLPoint4 : public CFLPoint3<Ty>
        {
        public:
            Ty w;

            CFLPoint4();

            virtual ~CFLPoint4();

            virtual void Get(Ty& tX, Ty& tY, Ty& tZ, Ty& tW) const;

            virtual double GetMagnitude() const override;

            virtual double GetSquareMagnitude() const override;

            virtual const CResult Offset(double x, double y, double z, double w);

            virtual const CResult Offset(float x, float y, float z, float w);

            virtual const CResult Offset(int32_t x, int32_t y, int32_t z, int32_t w);

            virtual const CResult Offset(int64_t x, int64_t y, int64_t z, int64_t w);

            virtual const CResult Offset(const CFLPoint4<double>& flp4);

            virtual const CResult Offset(const CFLPoint4<float>& flp4);

            virtual const CResult Offset(const CFLPoint4<double>* pFlp4);

            virtual const CResult Offset(const CFLPoint4<float>* pFlp4);

            virtual const CResult Add(const CFLPoint4<Ty>& rhs);

            virtual const CResult Add(Ty tX, Ty tY, Ty tZ, Ty tW);

            virtual const CResult Subtract(const CFLPoint4<Ty>& rhs);

            virtual const CResult Subtract(Ty tX, Ty tY, Ty tZ, Ty tW);

            virtual const CResult Multiply(double f64MulX, double f64MulY, double f64MulZ, double f64MulW);

            virtual const CResult Multiply(float f32MulX, float f32MulY, float f32MulZ, float f32MulW);

            virtual const CResult Multiply(int32_t i32MulX, int32_t i32MulY, int32_t i32MulZ, int32_t i32MulW);

            virtual const CResult Multiply(int64_t i64MulX, int64_t i64MulY, int64_t i64MulZ, int64_t i64MulW);

            virtual const CResult Multiply(const CFLPoint4<double>& flp4);

            virtual const CResult Multiply(const CFLPoint4<float>& flp4);

            virtual const CResult Multiply(const CFLPoint4<double>* pFlp4);

            virtual const CResult Multiply(const CFLPoint4<float>* pFlp4);

            virtual const CResult Multiply(double f64Scalar);

            virtual const CResult Multiply(float f32Scalar);

            virtual const CResult Multiply(int32_t i32Scalar);

            virtual const CResult Multiply(int64_t i64Scalar);

            virtual const CResult Divide(double f64Scalar);

            virtual const CResult Divide(float f32Scalar);

            virtual const CResult Divide(int32_t i32Scalar);

            virtual const CResult Divide(int64_t i64Scalar);

            virtual const CResult MatMul(const CMatrix<float>& mat4x4) override;

            virtual const CResult MatMul(const CMatrix<double>& mat4x4) override;

            virtual const CResult MatMul(const CMatrix<float>* pMat4x4) override;

            virtual const CResult MatMul(const CMatrix<double>* pMat4x4) override;
 

            virtual const CResult Normalize();

            virtual CFLPoint4<double> GetUnitVector() const;

            virtual CFLPoint4<double> GetUnitVector(const CFLPoint4<double>& flp4Target) const;

            virtual CFLPoint4<double> GetUnitVector(const CFLPoint4<double>* pFlp4Target) const;
 
            virtual void Clear() override;
 
            virtual EFigureDeclType GetDeclType() const override;
 
            virtual bool IsValid() const override;
            virtual bool IsFigureValid() const override;
 
            virtual const CResult MakeFigureInvalid() override;
 
            using CFLFigure::IsSpecEqual;
            virtual bool IsSpecEqual(const CFLFigure* pFlfRhs, EFigureSpecCompareType eSpecType = EFigureSpecCompareType_Coordinates) const override;

            virtual const CFLPoint4<Ty>& operator=(const CFLPoint4<Ty>& flp4);

            virtual bool operator==(const CFLPoint4<float>& flp4) const;

            virtual bool operator==(const CFLPoint4<double>& flp4) const;

            virtual bool operator!=(const CFLPoint4<float>& flp4) const;

            virtual bool operator!=(const CFLPoint4<double>& flp4) const;

            virtual const CFLPoint4<Ty>& operator+=(const double& value);

            virtual const CFLPoint4<Ty>& operator+=(const CFLPoint4<double>& flp4);

            virtual const CFLPoint4<Ty>& operator-=(const double& value);

            virtual const CFLPoint4<Ty>& operator-=(const CFLPoint4<double>& flp4);

            virtual const CFLPoint4<Ty>& operator*=(const double& value);

            virtual const CFLPoint4<Ty>& operator*=(const CFLPoint4<double>& flp4);

            virtual const CFLPoint4<Ty>& operator/=(const double& value);

            virtual const CFLPoint4<Ty>& operator/=(const CFLPoint4<double>& flp4);

            virtual CFLPoint4<double> operator+(const double& value) const;

            virtual CFLPoint4<double> operator+(const CFLPoint4<double>& flp4) const;

            virtual CFLPoint4<double> operator-(const double& value) const;

            virtual CFLPoint4<double> operator-(const CFLPoint4<double>& flp4) const;

            CFLPoint4<double> operator*(const double& value) const;

            CFLPoint4<double> operator*(const CFLPoint4<double>& flp4) const;

            virtual CFLPoint4<double> operator/(const double& value) const;

            virtual CFLPoint4<double> operator/(const CFLPoint4<double>& flp4) const;

            CFLPoint4<Ty> operator-() const;
 
            //Friend operator
            // Arithmetic operator

            friend CFLPoint4<double> operator+(const int32_t& value, const CFLPoint4<Ty>& point)
            {
                CFLPoint4<double> t(point);
                t += value;
                return t;
            }

            friend CFLPoint4<double> operator+(const int64_t& value, const CFLPoint4<Ty>& point)
            {
                CFLPoint4<double> t(point);
                t += value;
                return t;
            }

            friend CFLPoint4<double> operator+(const float& value, const CFLPoint4<Ty>& point)
            {
                CFLPoint4<double> t(point);
                t += value;
                return t;
            }

            friend CFLPoint4<double> operator+(const double& value, const CFLPoint4<Ty>& point)
            {
                CFLPoint4<double> t(point);
                t += value;
                return t;
            }

            friend CFLPoint4<double> operator-(const int32_t& value, const CFLPoint4<Ty>& point)
            {
                CFLPoint4<double> t(point);
                t *= -1.;
                t += value;
                return t;
            }

            friend CFLPoint4<double> operator-(const int64_t& value, const CFLPoint4<Ty>& point)
            {
                CFLPoint4<double> t(point);
                t *= -1.;
                t += value;
                return t;
            }

            friend CFLPoint4<double> operator-(const float& value, const CFLPoint4<Ty>& point)
            {
                CFLPoint4<double> t(point);
                t *= -1.;
                t += value;
                return t;
            }

            friend CFLPoint4<double> operator-(const double& value, const CFLPoint4<Ty>& point)
            {
                CFLPoint4<double> t(point);
                t *= -1.;
                t += value;
                return t;
            }

            friend CFLPoint4<double> operator*(const int32_t& value, const CFLPoint4<Ty>& point)
            {
                CFLPoint4<double> t(point);
                t *= value;
                return t;
            }

            friend CFLPoint4<double> operator*(const int64_t& value, const CFLPoint4<Ty>& point)
            {
                CFLPoint4<double> t(point);
                t *= value;
                return t;
            }

            friend CFLPoint4<double> operator*(const float& value, const CFLPoint4<Ty>& point)
            {
                CFLPoint4<double> t(point);
                t *= value;
                return t;
            }

            friend CFLPoint4<double> operator*(const double& value, const CFLPoint4<Ty>& point)
            {
                CFLPoint4<double> t(point);
                t *= value;
                return t;
            }

            friend CFLPoint4<double> operator/(const int32_t& value, const CFLPoint4<Ty>& point)
            {
                CFLPoint4<double> t((double)value / (double)point.x, (double)value / (double)point.y, (double)value / (double)point.z, (double)value / (double)point.w);
                return t;
            }

            friend CFLPoint4<double> operator/(const int64_t& value, const CFLPoint4<Ty>& point)
            {
                CFLPoint4<double> t((double)value / (double)point.x, (double)value / (double)point.y, (double)value / (double)point.z, (double)value / (double)point.w);
                return t;
            }

            friend CFLPoint4<double> operator/(const float& value, const CFLPoint4<Ty>& point)
            {
                CFLPoint4<double> t((double)value / (double)point.x, (double)value / (double)point.y, (double)value / (double)point.z, (double)value / (double)point.w);
                return t;
            }

            friend CFLPoint4<double> operator/(const double& value, const CFLPoint4<Ty>& point)
            {
                CFLPoint4<double> t((double)value / (double)point.x, (double)value / (double)point.y, (double)value / (double)point.z, (double)value / (double)point.w);
                return t;
            }
 
 
            virtual const CResult Set(const CFLFigure& flf) override;
            virtual const CResult Set(const CFLFigure* pFlf) override;

            virtual const CResult Set(double x, double y, double z, double w);

            virtual const CResult Set(float x, float y, float z, float w);

            virtual const CResult Set(int32_t x, int32_t y, int32_t z, int32_t w);

            virtual const CResult Set(int64_t x, int64_t y, int64_t z, int64_t w);

            virtual const CResult Set(const CFLPoint3<double>& flp3, double w = 0.);

            virtual const CResult Set(const CFLPoint3<float>& flp3, float w = 0.);
 

            virtual const CResult Set(const CFLPoint3<double>* pFlp3, double w = 0.);

            virtual const CResult Set(const CFLPoint3<float>* pFlp3, float w = 0.f);

            virtual const CResult Set(const CFLPoint4<double>& flp4);

            virtual const CResult Set(const CFLPoint4<float>& flp4);

            virtual const CResult Set(const CFLPoint4<double>* pFlp4);

            virtual const CResult Set(const CFLPoint4<float>* pFlp4);

            virtual const CResult Set(const CFLGeometry3DQuaternion<double>& quat);

            virtual const CResult Set(const CFLGeometry3DQuaternion<float>& quat);

            virtual const CResult Set(const CFLGeometry3DQuaternion<double>* pQuat);

            virtual const CResult Set(const CFLGeometry3DQuaternion<float>* pQuat);
 

            CFLPoint4(const CFLFigure& flf);

            CFLPoint4(const CFLFigure* pFlf);

            CFLPoint4(double x, double y, double z, double w);

            CFLPoint4(float x, float y, float z, float w);

            CFLPoint4(int32_t x, int32_t y, int32_t z, int32_t w);

            CFLPoint4(int64_t x, int64_t y, int64_t z, int64_t w);

            CFLPoint4(const CFLPoint3<double>& flp3, double w = 0.);

            CFLPoint4(const CFLPoint3<float>& flp3, float w = 0.f);

            CFLPoint4(const CFLPoint3<double>* pFlp3, double w = 0.);

            CFLPoint4(const CFLPoint3<float>* pFlp3, float w = 0.f);

            CFLPoint4(const CFLPoint4<double>& flp4);

            CFLPoint4(const CFLPoint4<float>& flp4);
 

            CFLPoint4(const CFLPoint4<double>* pFlp4);

            CFLPoint4(const CFLPoint4<float>* pFlp4);

            CFLPoint4(const CFLGeometry3DQuaternion<double>& quat);

            CFLPoint4(const CFLGeometry3DQuaternion<float>& quat);

            CFLPoint4(const CFLGeometry3DQuaternion<double>* pQuat);

            CFLPoint4(const CFLGeometry3DQuaternion<float>* pQuat);
 
            Base::ECPUInstructionType m_eCPUInstruction;
            SupportToDuplicateObject(CFLPoint4<Ty>, *this);
            DeclareGetClassType();
        };
 
        typedef CFLPoint4<float> CFLPoint4F;
        typedef CFLPoint4<double> CFLPoint4D;
    }
}