CUPlane.h

//
//  CUPlane.h
//  Cornell University Game Library (CUGL)
//
//  This module provides support for a 3d plane.
//
//  Because math objects are intended to be on the stack, we do not provide
//  any shared pointer support in this class.
//
//  CUGL MIT License:
//      This software is provided 'as-is', without any express or implied
//      warranty.  In no event will the authors be held liable for any damages
//      arising from the use of this software.
//
//      Permission is granted to anyone to use this software for any purpose,
//      including commercial applications, and to alter it and redistribute it
//      freely, subject to the following restrictions:
//
//      1. The origin of this software must not be misrepresented; you must not
//      claim that you wrote the original software. If you use this software
//      in a product, an acknowledgment in the product documentation would be
//      appreciated but is not required.
//
//      2. Altered source versions must be plainly marked as such, and must not
//      be misrepresented as being the original software.
//
//      3. This notice may not be removed or altered from any source distribution.
//
//  Author: Walker White
//  Version: 6/20/16
 
#ifndef __CU_PLANE_H__
#define __CU_PLANE_H__
 
#include "CUVec3.h"
#include "CUMat4.h"
#include "CURay.h"
 
namespace cugl {
 
class Plane {
#pragma mark Values
public:
    enum class Side {
        INCIDENT,
        BACK,
        FRONT
    };
    
    Vec3 normal;
    float offset;
    
    static const Plane XY;
    static const Plane XZ;
    static const Plane YZ;
    
#pragma mark -
#pragma mark Constructors
 
    Plane () : normal(Vec3::UNIT_Z), offset(0) {}
 
    Plane (const Vec3& normal, float dist=0) {
        set(normal,dist);
    }
    
    Plane (const Vec3& normal, const Vec3& point) {
        set(normal,point);
    }
    
    Plane(const Vec3&  point1, const Vec3& point2, const Vec3& point3) {
        set(point1, point2, point3);
    }
 
    Plane(float a, float b, float c, float d) {
        set(a,b,c,d);
    }
    
    Plane(const Plane& plane) {
        set(plane);
    }
    
    ~Plane() {}
    
#pragma mark -
#pragma mark Setters
 
    Plane& operator=(const Plane& plane) {
        return set(plane);
    }
    
    Plane& operator=(const Vec3& normal) {
        return set(normal,0);
    }
    
    Plane& set(const Vec3& normal, float dist=0);
    
    Plane& set(const Vec3& normal, const Vec3& point);
    
    Plane& set(const Vec3&  point1, const Vec3& point2, const Vec3& point3);
    
    Plane& set(float a, float b, float c, float d);
    
    Plane& set(const Plane& plane) {
        normal = plane.normal;
        offset = plane.offset;
        return *this;
    }
    
#pragma mark -
#pragma mark Static Arithmetic
 
    static Plane* multiply(const Plane& plane, const Mat4& mat, Plane* dst);
 
    static float intersection(const Plane& plane, const Ray& ray);
 
#pragma mark -
#pragma mark Arithmetic
 
    Plane& multiply(const Mat4& mat) {
        return *(multiply(*this,mat,this));
    }
 
    Plane& operator*=(const Mat4& mat) {
        return *(multiply(*this,mat,this));
    }
 
    const Plane operator*(const Mat4& mat) const {
        Plane result;
        return *(multiply(*this,mat,&result));
    }
 
#pragma mark -
#pragma mark Plane Methods
 
    float distance(const Vec3& point) const {
        return normal.dot(point) + offset;
    }
    
    float getIntersection(const Ray& ray) const {
        return intersection(*this,ray);
    }
    
    bool contains(const Vec3& point, float variance=CU_MATH_EPSILON) const {
        return fabsf(distance(point)) <= variance;
    }
    
    Side sideOf(const Vec3& point) const {
        float dist = normal.dot(point) + offset;
        return (dist == 0 ? Side::INCIDENT : (dist < 0 ? Side::BACK : Side::FRONT));
    }
    
     Side sideOf(float x, float y, float z) const {
         return sideOf(Vec3(x,y,z));
     }
    
    
    bool isFrontFacing(const Vec3& direction) const {
        float dot = normal.dot(direction);
        return dot <= 0;
    }
    
#pragma mark -
#pragma mark Comparisons
 
    bool operator==(const Plane& p) const {
        return normal == p.normal && offset == p.offset;
    }
    
    bool operator!=(const Plane& p) const {
        return normal != p.normal || offset != p.offset;
    }
    
    bool equals(const Plane& p, float variance=CU_MATH_EPSILON) const {
        return (normal.equals(p.normal,variance) &&
                CU_MATH_APPROX(offset,p.offset,variance));
    }
    
#pragma mark -
#pragma mark Conversion Methods
 
    std::string toString(bool verbose = false) const;
    
    operator std::string() const { return toString(); }};
}
 
#endif /* __CU_PLANE_H__ */