Plane.hpp

Go to the documentation of this file.

#include <etk/types.hpp>

#pragma once

#include <etk/debug.hpp>
#include <vector>

namespace etk {
    template <typename T> class Plane {
        private:
            etk::Vector3D<T> m_normal; 
            T m_intercept; 
        public:
            Plane() :
              m_normal(0, 0, 0),
              m_intercept(0) {
                
            }
            Plane(etk::Vector3D<T> _normal, T _intercept=0) :
              m_normal(_normal),
              m_intercept(_intercept) {
                
            }
            Plane(const Plane& _obj) :
              m_normal(_obj.m_normal),
              m_intercept(_obj.m_intercept) {
                
            }
            void setNormal(const etk::Vector3D<T>& _obj) {
                m_normal = _obj;
            }
            void setIntercept(float _intercept) {
                m_intercept=_intercept;
            }
            void setFromPoints(const etk::Vector3D<T>& _p0,
                               const etk::Vector3D<T>& _p1,
                               const etk::Vector3D<T>& _p2) {
                m_normal = (_p1 - _p0).cross(_p2 - _p0);
                m_normal.normalize();
                calculateIntercept(_p0);
            }
            void calculateIntercept(const etk::Vector3D<T>& _pointOnPlane) {
                m_intercept=-m_normal.dot(_pointOnPlane);
            }
            void normalize() {
                float normalLength = m_normal.getLength();
                if (normalLength == 0) {
                    return;
                }
                m_normal /= normalLength;
                m_intercept /= normalLength;
            }
            const etk::Vector3D<T>& getNormal() const {
                return m_normal;
            }
            T getIntercept() const {
                return m_intercept;
            }
            etk::Vector3D<T> intersect3(const Plane<T>& _p2,
                                        const Plane<T>& _p3) {
                float denominator = m_normal.dot((_p2.m_normal).cross(_p3.m_normal));
                //scalar triple product of normals
                if(denominator==0.0f) {
                    //no intersection
                    return etk::Vector3D<T>(0,0,0);
                }
                etk::Vector3D<T> temp1, temp2, temp3;
                temp1 = (_p2.m_normal.cross(_p3.m_normal))*m_intercept;
                temp2 = (_p3.m_normal.cross(m_normal)) * _p2.m_intercept;
                temp3 = (m_normal.cross(_p2.m_normal)) * _p3.m_intercept;
                return (temp1+temp2+temp3) / (-denominator);
            }
            float getDistance(const etk::Vector3D<T>& _point) const {
                return   _point.x() * m_normal.x()
                       + _point.y() * m_normal.y()
                       + _point.z() * m_normal.z()
                       + m_intercept;
            }
            Plane<T> linearInterpolate(const Plane<T>& _p2, float _factor) {
                Plane<T> result;
                result.m_normal=m_normal*(1.0f-_factor) + _p2.m_normal*_factor;
                result.m_normal.normalize();
                result.m_intercept=m_intercept*(1.0f-_factor) + _p2.m_intercept*_factor;
                return result;
            }
            bool operator==(const Plane<T>& _obj) const {
                if(    m_normal == _obj.m_normal
                    && m_intercept == _obj.m_intercept) {
                    return true;
                }
                return false;
            }
            bool operator!=(const Plane<T>& _obj) const {
                return!((*this) == _obj);
            }
    };
}