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);
 
            virtual const CResult MatMul(const CMatrix<double>& mat4x4);
 
            virtual const CResult MatMul(const CMatrix<float>* pMat4x4);
 
            virtual const CResult MatMul(const CMatrix<double>* pMat4x4);
 
 
            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;
 
            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;
 
 
            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;
    }
}