Eigene Dateien/FlowVis/src/VPlane.h

Go to the documentation of this file.

#pragma once

#ifndef __v_plane_h
#define __v_plane_h

#include "VVector.h"
#include "float.h"

static float EPSILON = FLT_EPSILON; 
class VPlane
{
public:
        float & nx;
        float & ny;
        float & nz;
        float & d;

        float values[4];

        VVector mNormal;

        VPlane() : nx(values[0]), ny(values[1]), nz(values[2]), d(values[3])
        {
                values[0] = 0.0f;
                values[1] = 0.0f;
                values[2] = 0.0f;
                values[3] = 0.0f;

                 mNormal = VVector(nx, ny, nz);
        }

        VPlane(float n_x, float n_y, float n_z, float _d) : nx(values[0]), ny(values[1]), nz(values[2]), d(values[3]) 
        {
                values[0] = n_x;
                values[1] = n_y;
                values[2] = n_z;
                values[3] = _d;

                mNormal = VVector(nx, ny, nz);
        }

        VPlane(VVector m_Vec1, VVector m_Vec2, VVector m_Vec3): nx(values[0]), ny(values[1]), nz(values[2]), d(values[3])
        {
                VVector auxVec1 = m_Vec1 - m_Vec2;
                VVector auxVec2 = m_Vec3 - m_Vec2;
                
                mNormal = auxVec2.getCross(auxVec1);
                mNormal.normalize();

                nx = mNormal.getX();
                ny = mNormal.getY();
                nz = mNormal.getZ();

                d = -mNormal.getDot(m_Vec2);
        }

        VPlane(VVector m_Normal, VVector m_Point): nx(values[0]), ny(values[1]), nz(values[2]), d(values[3])
        {
                nx = m_Normal.getX();
                ny = m_Normal.getY();
                nz = m_Normal.getZ();

                d = -m_Normal.getDot(m_Point);
        }

        VPlane & normalize()
        {
                float l = sqrtf(nx * nx + ny * ny + nz * nz);

                if (l > 0)
                        l = 1 / l;
                else
                        l = 0;

                nx *= l; 
                ny *= l; 
                nz *= l;
                d *= l;

                return *this;
        }

        VPlane & operator=(const VPlane rhs)
        {
                this->d = rhs.d;
                this->nx = rhs.nx;
                this->ny = rhs.ny;
                this->nz = rhs.nz;
                this->mNormal = rhs.mNormal;

                return (*this);
        }

        bool isInFront(VVector& p) const
        {
                return ((nx * p.getX() + ny * p.getY() + nz * p.getZ() + d) >= 0);
        }

        float distance(const VVector& p) const
        {
                return (nx * p.getX() + ny * p.getY() + nz * p.getZ() + d);
        }

        bool intersect(const VVector& start, const VVector& dir, VVector& result) const
        {
                float denom = nx * dir.getX() + ny * dir.getY() + nz * dir.getZ();
                float s = start.getX() * nx + start.getY() * ny + start.getZ() * nz + d;

                if (fabs(denom) < EPSILON)
                {
                        if (fabs(s) < EPSILON)
                        {
                                result = start;
                                return true;
                        }
                        else
                        {
                                return false;
                        }
                }

                float t = s / (-denom);
                result = start + dir * t;
                return true;
        }

        bool intersects(const VVector& start, const VVector& dir) const
        {
                VVector temp;
                return intersect(start, dir, temp);
        }

        VVector getNormal()
        {
                return VVector(nx, ny, nz);
        }
        
        std::string toString()
        {
                std::stringstream s;
                s << "P([" << "(" << nx << ", " << ny << ", " << nz << ")" << d << "])";
                return s.str();

        }

        float * getArray()
        {
                return values;
        }
};              

#endif //__v_plane_h

---