FLFrustum3.h

#pragma once

 
#include "FLQuad3.h"
#include "FLGeometry3DPlane.h"
#include "FLGeometry3DVector.h"

namespace FLImaging
{
    namespace Foundation
    {
        template<typename T>
        class FL_EXPORT CFLFrustum3 : public CFLFigure
        {
        public:
            CFLQuad3<T> flqQuads[2];

            enum EVertex
            {
                EVertex_LeftTopNear = 0,

                EVertex_RightTopNear,

                EVertex_RightBottomNear,

                EVertex_LeftBottomNear,

                EVertex_LeftTopFar,

                EVertex_RightTopFar,

                EVertex_RightBottomFar,

                EVertex_LeftBottomFar,

                EVertex_Count,
            };

            enum EPlane
            {
                EPlane_Top = 0,

                EPlane_Bottom,

                EPlane_Left,

                EPlane_Right,

                EPlane_Near,

                EPlane_Far,
            };

            CFLFrustum3();

            virtual ~CFLFrustum3();

            CFLFrustum3(const CFLFrustum3<float>& rhs);

            CFLFrustum3(const CFLFrustum3<double>& rhs);

            CFLFrustum3(const CFLFrustum3<float>* pRhs);

            CFLFrustum3(const CFLFrustum3<double>* pRhs);

            CFLFrustum3(const Base::TQuadrilateralSolid3<float>& tQuadrilateralSolid3);
            
            CFLFrustum3(const Base::TQuadrilateralSolid3<float>* pTQuadrilateralSolid3);

            CFLFrustum3(const Base::TQuadrilateralSolid3<double>& tQuadrilateralSolid3);

            CFLFrustum3(const Base::TQuadrilateralSolid3<double>* pTQuadrilateralSolid3);

            CFLFrustum3(const CFLQuad3<float>& flqQuad0, const CFLQuad3<float>& flqQuad1);

            CFLFrustum3(const CFLQuad3<double>& flqQuad0, const CFLQuad3<double>& flqQuad1);

            CFLFrustum3(const CFLQuad3<float>* pFlqQuad0, const CFLQuad3<float>* pFlqQuad1);

            CFLFrustum3(const CFLQuad3<double>* pFlqQuad0, const CFLQuad3<double>* pFlqQuad1);

            CFLFrustum3(const CFLFigure& flf);

            CFLFrustum3(const CFLFigure* pFlf);

            virtual const CResult Set(const CFLFrustum3<float>& flfr);

            virtual const CResult Set(const CFLFrustum3<double>& flfr);

            virtual const CResult Set(const CFLFrustum3<float>* pFlfr);

            virtual const CResult Set(const CFLFrustum3<double>* pFlfr);

            virtual const CResult Set(const Base::TQuadrilateralSolid3<float>& tQuadrilateralSolid3);

            virtual const CResult Set(const Base::TQuadrilateralSolid3<double>& tQuadrilateralSolid3);

            virtual const CResult Set(const Base::TQuadrilateralSolid3<float>* pTQuadrilateralSolid3);

            virtual const CResult Set(const Base::TQuadrilateralSolid3<double>* pTQuadrilateralSolid3);

            virtual const CResult Set(const CFLQuad3<float>& flqQuad0, const CFLQuad3<float>& flqQuad1);

            virtual const CResult Set(const CFLQuad3<double>& flqQuad0, const CFLQuad3<double>& flqQuad1);

            virtual const CResult Set(const CFLQuad3<float>* pFlqQuad0, const CFLQuad3<float>* pFlqQuad1);

            virtual const CResult Set(const CFLQuad3<double>* pFlqQuad0, const CFLQuad3<double>* pFlqQuad1);

            virtual const CResult SetVertex(EVertex eVertexPos, const Base::TPoint3<float>& tp3) sealed;

            virtual const CResult SetVertex(EVertex eVertexPos, const Base::TPoint3<double>& tp3) sealed;

            virtual const CResult SetVertex(EVertex eVertexPos, const Base::TPoint3<float>* pTp3) sealed;

            virtual const CResult SetVertex(EVertex eVertexPos, const Base::TPoint3<double>* pTp3) sealed;
            
            virtual const CResult SetVertex(EVertex eVertexPos, const Foundation::CFLPoint3<float>& flp3) sealed;

            virtual const CResult SetVertex(EVertex eVertexPos, const Foundation::CFLPoint3<double>& flp3) sealed;

            virtual const CResult SetVertex(EVertex eVertexPos, const Foundation::CFLPoint3<float>* pFlp3) sealed;

            virtual const CResult SetVertex(EVertex eVertexPos, const Foundation::CFLPoint3<double>* pFlp3) sealed;

            virtual const Foundation::CFLPoint3<T>* GetVertex(EVertex eVertexPos) const sealed;

            virtual const CFLGeometry3DVector<T> GetEquationOfPlane(EPlane ePlane) const sealed;

            virtual bool Contains(const Base::TPoint3<float>& tp3) const;

            virtual bool Contains(const Base::TPoint3<double>& tp3) const;

            virtual bool Contains(const Base::TPoint3<float>* pTp3) const;

            virtual bool Contains(const Base::TPoint3<double>* pTp3) const;

            virtual bool Contains(const Foundation::CFLPoint3<float>& flp3) const;

            virtual bool Contains(const Foundation::CFLPoint3<double>& flp3) const;

            virtual bool Contains(const Foundation::CFLPoint3<float>* pFlp3) const;

            virtual bool Contains(const Foundation::CFLPoint3<double>* pFlp3) const;

            virtual const CResult Contains(const Base::CFLArray<Base::TPoint3<float>>& flaVertices, Base::CFLArray<int32_t>& flaResult, bool bClearResult = true) const;

            virtual const CResult Contains(const Base::CFLArray<Base::TPoint3<double>>& flaVertices, Base::CFLArray<int32_t>& flaResult, bool bClearResult = true) const;

            virtual const CResult Contains(const Base::CFLArray<Base::TPoint3<float>>* pFlaVertices, Base::CFLArray<int32_t>& flaResult, bool bClearResult = true) const;

            virtual const CResult Contains(const Base::CFLArray<Base::TPoint3<double>>* pFlaVertices, Base::CFLArray<int32_t>& flaResult, bool bClearResult = true) const;

            virtual const CResult Contains(const Base::CFLArray<Base::TPoint3<float>>& flaVertices, const Base::CFLArray<int32_t>& flaTargetIndex, Base::CFLArray<int32_t>& flaResult, bool bClearResult = true) const;

            virtual const CResult Contains(const Base::CFLArray<Base::TPoint3<double>>& flaVertices, const Base::CFLArray<int32_t>& flaTargetIndex, Base::CFLArray<int32_t>& flaResult, bool bClearResult = true) const;

            virtual const CResult Contains(const Base::CFLArray<Base::TPoint3<float>>* pFlaVertices, const Base::CFLArray<int32_t>& flaTargetIndex, Base::CFLArray<int32_t>& flaResult, bool bClearResult = true) const;

            virtual const CResult Contains(const Base::CFLArray<Base::TPoint3<double>>* pFlaVertices, const Base::CFLArray<int32_t>& flaTargetIndex, Base::CFLArray<int32_t>& flaResult, bool bClearResult = true) const;

            virtual bool IsCollision(const Base::TPoint3<float>& tp3Begin, const Base::TPoint3<float>& tp3End) const;

            virtual bool IsCollision(const Base::TPoint3<double>& tp3Begin, const Base::TPoint3<double>& tp3End) const;

            virtual bool IsCollision(const Base::TPoint3<float>* pTp3Begin, const Base::TPoint3<float>* pTp3End) const;

            virtual bool IsCollision(const Base::TPoint3<double>* pTp3Begin, const Base::TPoint3<double>* pTp3End) const;

            virtual bool IsCollision(const Foundation::CFLPoint3<float>& flp3Begin, const Foundation::CFLPoint3<float>& flp3End) const;

            virtual bool IsCollision(const Foundation::CFLPoint3<double>& flp3Begin, const Foundation::CFLPoint3<double>& flp3End) const;

            virtual bool IsCollision(const Foundation::CFLPoint3<float>* pFlp3Begin, const Foundation::CFLPoint3<float>* pFlp3End) const;

            virtual bool IsCollision(const Foundation::CFLPoint3<double>* pFlp3Begin, const Foundation::CFLPoint3<double>* pFlp3End) const;
 
            using CFLFigure::Offset;
            virtual const CResult Offset(double x, double y) override;
            virtual const CResult Offset(int32_t val) override;
            virtual const CResult Offset(int64_t val) override;
            virtual const CResult Offset(float val) override;
            virtual const CResult Offset(double val) override;

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

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

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

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

            virtual const CResult Offset(const CFLPoint3<double>& flp3);

            virtual const CResult Offset(const CFLPoint3<float>& flp3);

            virtual const CResult Offset(const CFLPoint3<double>* pFlp3);

            virtual const CResult Offset(const CFLPoint3<float>* pFlp3);

            virtual const CResult Offset(const Base::TPoint3<float>& tpPoint);

            virtual const CResult Offset(const Base::TPoint3<double>& tpPoint);

            virtual const CResult Offset(const Base::TPoint3<float>* pTpPoint);

            virtual const CResult Offset(const Base::TPoint3<double>* pTpPoint);
 
            using CFLFigure::Multiply;
            virtual const CResult Multiply(double x, double y) override;
            virtual const CResult Multiply(int32_t val) override;
            virtual const CResult Multiply(int64_t val) override;
            virtual const CResult Multiply(float val) override;
            virtual const CResult Multiply(double val) override;

            virtual const CResult Multiply(const CFLPoint3<float>& flpPoint);

            virtual const CResult Multiply(const CFLPoint3<double>& flpPoint);

            virtual const CResult Multiply(const CFLPoint3<float>* pFlpPoint);

            virtual const CResult Multiply(const CFLPoint3<double>* pFlpPoint);

            virtual const CResult Multiply(const Base::TPoint3<float>& tpPoint);

            virtual const CResult Multiply(const Base::TPoint3<double>& tpPoint);

            virtual const CResult Multiply(const Base::TPoint3<float>* pTpPoint);

            virtual const CResult Multiply(const Base::TPoint3<double>* pTpPoint);

            virtual const CResult Multiply(double x, double y, double z);
 
 
            virtual const CResult Set(const CFLFigure& flf) override;
            virtual const CResult Set(const CFLFigure* pFlf) override;
 
            virtual void Clear() override;
 
            virtual EFigureDeclType GetDeclType() const override;
            virtual EFigureTemplateType GetTemplateType() const override;
 
            using CFLFigure::IsSpecEqual;
            virtual bool IsSpecEqual(const CFLFigure* pFlfRhs, EFigureSpecCompareType eSpecType = EFigureSpecCompareType_Coordinates) const override;
 

            const CFLFrustum3<T>& operator=(const CFLFrustum3<float>& rhs);

            const CFLFrustum3<T>& operator=(const CFLFrustum3<double>& rhs);

            const CFLFrustum3<T>& operator=(const Base::TQuadrilateralSolid3<float>& rhs);

            const CFLFrustum3<T>& operator=(const Base::TQuadrilateralSolid3<double>& rhs);

            const CFLFrustum3<T>& operator+=(const double& value);

            const CFLFrustum3<T>& operator+=(const CFLPoint3<float>& flpPoint);

            const CFLFrustum3<T>& operator+=(const CFLPoint3<double>& flpPoint);

            const CFLFrustum3<T>& operator+=(const Base::TPoint3<float>& tpPoint);

            const CFLFrustum3<T>& operator+=(const Base::TPoint3<double>& tpPoint);

            const CFLFrustum3<T>& operator-=(const double& value);

            const CFLFrustum3<T>& operator-=(const CFLPoint3<float>& flpPoint);

            const CFLFrustum3<T>& operator-=(const CFLPoint3<double>& flpPoint);

            const CFLFrustum3<T>& operator-=(const Base::TPoint3<float>& tpPoint);

            const CFLFrustum3<T>& operator-=(const Base::TPoint3<double>& tpPoint);

            const CFLFrustum3<T>& operator*=(const double& value);

            const CFLFrustum3<T>& operator*=(const CFLPoint3<float>& flpPoint);

            const CFLFrustum3<T>& operator*=(const CFLPoint3<double>& flpPoint);

            const CFLFrustum3<T>& operator*=(const Base::TPoint3<float>& tpPoint);

            const CFLFrustum3<T>& operator*=(const Base::TPoint3<double>& tpPoint);

            const CFLFrustum3<T>& operator/=(const double& value);

            const CFLFrustum3<T>& operator/=(const CFLPoint3<float>& flpPoint);

            const CFLFrustum3<T>& operator/=(const CFLPoint3<double>& flpPoint);

            const CFLFrustum3<T>& operator/=(const Base::TPoint3<float>& tpPoint);

            const CFLFrustum3<T>& operator/=(const Base::TPoint3<double>& tpPoint);

            CFLFrustum3<T> operator+(const double& value) const;

            CFLFrustum3<T> operator+(const Base::TPoint3<float>& tpPoint) const;

            CFLFrustum3<T> operator+(const Base::TPoint3<double>& tpPoint) const;

            CFLFrustum3<T> operator+(const CFLPoint3<float>& flpPoint) const;

            CFLFrustum3<T> operator+(const CFLPoint3<double>& flpPoint) const;

            CFLFrustum3<T> operator-(const double& value) const;

            CFLFrustum3<T> operator-(const Base::TPoint3<float>& tpPoint) const;

            CFLFrustum3<T> operator-(const Base::TPoint3<double>& tpPoint) const;

            CFLFrustum3<T> operator-(const CFLPoint3<float>& flpPoint) const;

            CFLFrustum3<T> operator-(const CFLPoint3<double>& flpPoint) const;

            CFLFrustum3<T> operator*(const double& value) const;

            CFLFrustum3<T> operator*(const Base::TPoint3<float>& tpPoint) const;

            CFLFrustum3<T> operator*(const Base::TPoint3<double>& tpPoint) const;

            CFLFrustum3<T> operator*(const CFLPoint3<float>& flpPoint) const;

            CFLFrustum3<T> operator*(const CFLPoint3<double>& flpPoint) const;

            CFLFrustum3<T> operator/(const double& value) const;

            CFLFrustum3<T> operator/(const Base::TPoint3<float>& tpPoint) const;

            CFLFrustum3<T> operator/(const Base::TPoint3<double>& tpPoint) const;

            CFLFrustum3<T> operator/(const CFLPoint3<float>& flpPoint) const;

            CFLFrustum3<T> operator/(const CFLPoint3<double>& flpPoint) const;

            CFLFrustum3<T> operator-() const;

            friend CFLFrustum3<T> operator+(const double& value, const CFLFrustum3<T>& flfr)
            {
                CFLFrustum3<T> t(flfr);
                t += value;
                return t;
            }

            friend CFLFrustum3<T> operator-(const double& value, const CFLFrustum3<T>& flfr)
            {
                CFLFrustum3<T> t(flfr);
                t *= -1.;
                t += value;
                return t;
            }

            friend CFLFrustum3<T> operator*(const double& value, const CFLFrustum3<T>& flfr)
            {
                CFLFrustum3<T> t(flfr);
                t *= value;
                return t;
            }

            friend CFLFrustum3<T> operator/(const double& value, const CFLFrustum3<T>& flfr)
            {
                CFLFrustum3<T> t;
                t.flqQuads[0] = value / flfr.flqQuads[0];
                t.flqQuads[1] = value / flfr.flqQuads[1];
                return t;
            }
 
 
            SupportToDuplicateObject(CFLFrustum3<T>, *this);
            DeclareGetClassType();
        };
 
        typedef CFLFrustum3<float> CFLFrustum3F;
        typedef CFLFrustum3<double> CFLFrustum3D;
    }
}