CUFrustum.h

//
//  CUFrustum.h
//  Cornell University Game Library (CUGL)
//
//  This module provides support for a 3d viewing frustrum.  This is a bit
//  heavy-weight for our cameras, so we pulled it out..
//
//  Because math objects are intended to be on the stack, we do not provide
//  any shared pointer support in this class.
//
//  CUGL zlib 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_FRUSTRUM_H__
#define __CU_FRUSTRUM_H__

#include "CUPlane.h"
#include "CUVec3.h"
#include "../util/CUDebug.h"

namespace cugl {


class Frustum {
#pragma mark Values
public:
    static const int PLANE_COUNT = 6;
    static const int CORNER_COUNT = 8;
    
    enum class Region {
        INSIDE,
        OUTSIDE,
        INTERSECT
    };
    
    
private:
    Plane _planes[6];
    
    Vec3 _points[8];

    
public:
    enum class Side : unsigned int {
        CLOSE = 0,
        AWAY = 1,
        LEFT = 2,
        RIGHT  = 3,
        TOP = 4,
        BOTTOM  = 5
    };
    
#pragma mark Constructors

    Frustum () {
        set(Mat4::IDENTITY);
    }

    Frustum (const Mat4& inverseView) {
        set(inverseView);
    }
    
    Frustum (const Frustum& frustum) {
        set(frustum);
    }
    
    ~Frustum() {}

#pragma mark -
#pragma mark Setters

    Frustum& operator=(const Mat4& inverseView) {
        return set(inverseView);
    }

    Frustum& operator=(const Frustum& frustum) {
        return set(frustum);
    }
    
    Frustum& set(const Mat4& inverseView);
    
    Frustum& set(const Frustum& frustum);
    

#pragma mark -
#pragma mark Attributes
    
    const Plane& getPlane(Side side) {
        CUAssertLog((unsigned int)side < PLANE_COUNT, "Side is not valid");
        return _planes[(unsigned int)side];
    }

    const Vec3& getCorner(unsigned int index) {
        CUAssertLog(index < CORNER_COUNT, "Index is not valid");
        return _points[index];
    }

#pragma mark -
#pragma mark Containment Methods

    Region find(const Vec3 point);
    
    Region find(float x, float y, float z) {
        return find(Vec3(x,y,z));
    }
    
    Region findSphere(const Vec3& center, float radius);
    
    Region findSphere(float x, float y, float z, float radius) {
        return findSphere(Vec3(x,y,z),radius);
    }
    
    Region findSphereWithoutNearFar(const Vec3& center, float radius);
    
    Region findSphereWithoutNearFar(float x, float y, float z, float radius) {
        return findSphereWithoutNearFar(Vec3(x,y,z),radius);
    }
    
    Region findBox(const Vec3& center, const Vec3& dimension) {
        return findBox(center.x, center.y, center.z, dimension.x / 2, dimension.y / 2, dimension.z / 2);
    }
    
    Region findBox(float x, float y, float z, float halfWidth, float halfHeight, float halfDepth);
    
};
    
}
#endif /* __CU_FRUSTRUM_H__ */