ViewFrustum.h

Go to the documentation of this file.

#ifndef GlobeEngine_ViewFrustum_h
#define GlobeEngine_ViewFrustum_h

#include "OpenGL_Includes.h"
#include "DrawableComponent.h"
#include <vmmlib/vmmlib.hpp>

namespace ge {
    
    struct ViewFrustumProperties
    {
        double fieldOfView;
        double aspectRatio;
        double nearPlane;
        double farPlane;
        
        ViewFrustumProperties(){
            this->fieldOfView = 0.0;
            this->aspectRatio = 0.0;
            this->nearPlane = 0.0;
            this->farPlane = 0.0;
        }
        
        ViewFrustumProperties(
            double _fieldOfView,
            double _aspectRatio,
            double _nearPlane,
            double _farPlane) :
        fieldOfView(_fieldOfView), aspectRatio(_aspectRatio),
        nearPlane(_nearPlane), farPlane(_farPlane) {}
        
        // copy constructor
        ViewFrustumProperties(const std::shared_ptr<ViewFrustumProperties> copy){
            fieldOfView = copy->fieldOfView;
            aspectRatio = copy->aspectRatio;
            nearPlane = copy->nearPlane;
            farPlane = copy->farPlane;
        }
    };
    
    struct ViewFrustumPlane
    {
        vmml::Vector3d normal;
        vmml::Vector3d aPoint;
        double normalDotAPoint;
    };
    
    class ViewFrustum : public ge::DrawableComponent
    {
    public:
        ViewFrustum() {clear(); };
        ~ViewFrustum() {destroy(); };
        void clear();
        void destroy();
        void create(){};
        void create(vmml::Vector3d eyePosition,
                    vmml::Vector3d view,
                    vmml::Vector3d up,
                    vmml::Vector3d right,
                    ViewFrustumProperties _frustumProp);
        void createVAO();
        void update();
        void draw(std::shared_ptr<ge::Camera> _cam);
        void move(vmml::Vector3d eyePosition,
                  vmml::Vector3d view,
                  vmml::Vector3d up,
                  vmml::Vector3d right);
        void extractPlaneNormals();
        const vmml::Vector3d* getFrustumPoints() const;
        
        void calculateAABB();
        bool isInFrustum(vmml::Vector3d _position, double radius) const;
        bool isStrictlyInFrustum(vmml::Vector3d _position, double radius) const;
        bool isAABB2DRoughlyInFrustumAABB2D(vmml::Vector4d _rect) const;
        bool isRoughlyInFrustumAABB3D(vmml::Vector3d _position) const;
        bool isAABB2DFarAwayFromFrustumAABB2D(vmml::Vector4d _rect, double _farFactor=1.0) const;
        bool isInFrustumSphere(vmml::Vector3d _position) const;
        bool isInFrustumSphere(BoundingSphere* _boundingSphere) const;
        void createBounds(vmml::Vector3d mid, double radius);
        
        bool isViewed();
        
        void setViewFrustumProperties(ViewFrustumProperties _in);
        const ViewFrustumProperties* getViewFrustumProperties();
        
        double getNearPlaneDist() const;
        double getFarPlaneDist() const;
        double getFieldOfView() const;
        double getAspectRatio() const;
        double getZBufferDepth() const;

        void setAspectRatio(double _aspectRatio);
        
    private:
        
        bool isPointInsidePlane(ViewFrustumPlane _plane, vmml::Vector3d point, double _radius) const;
        
        double pointToPlaneDistance(ViewFrustumPlane _plane, vmml::Vector3d point) const;
        
        vmml::Vector3d points[8];
        
        ViewFrustumPlane planes[6];
        vmml::Vector3d nearplaneCenter;
        vmml::Vector3d farplaneCenter;
        
        // AABB
        vmml::Vector3d aabbMin;
        vmml::Vector3d aabbMax;
        
        ViewFrustumProperties properties;
        double zBufferDepth;

    };
}
#endif