_view_frustum_8h_source.html

//

//  ViewFrustum.h

//  libraries/shared/src

//

//  Created by Brad Hefta-Gaub on 04/11/13.

//  Copyright 2013 High Fidelity, Inc.

//

//  Simple view frustum class.

//

//  Distributed under the Apache License, Version 2.0.

//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html

//


#ifndef hifi_ViewFrustum_h

#define hifi_ViewFrustum_h


#include <glm/glm.hpp>

#include <glm/gtc/quaternion.hpp>


#include "AABox.h"

#include "AACube.h"

#include "CubeProjectedPolygon.h"

#include "Plane.h"

#include "RegisteredMetaTypes.h"

#include "Transform.h"


const int NUM_FRUSTUM_CORNERS = 8;

const int NUM_FRUSTUM_PLANES = 6;


const float DEFAULT_CENTER_SPHERE_RADIUS = 3.0f;

const float DEFAULT_FIELD_OF_VIEW_DEGREES = 45.0f;

const float DEFAULT_ASPECT_RATIO = 16.0f/9.0f;

const float DEFAULT_NEAR_CLIP = 0.08f;

const float DEFAULT_FAR_CLIP = 16384.0f;


class ViewFrustum {

public:

    // setters for camera attributes

    void setPosition(const glm::vec3& position);

    void setOrientation(const glm::quat& orientation);


    // getters for camera attributes

    const glm::vec3& getPosition() const { return _position; }

    const glm::quat& getOrientation() const { return _orientation; }

    const glm::vec3& getDirection() const { return _direction; }

    const glm::vec3& getUp() const { return _up; }

    const glm::vec3& getRight() const { return _right; }


    // setters for lens attributes

    void setProjection(const glm::mat4 & projection);

    void setProjection(float cameraFov, float cameraAspectRatio, float cameraNearClip, float cameraFarClip);

    void setFocalLength(float focalLength) { _focalLength = focalLength; }

    bool isPerspective() const;


    // getters for lens attributes

    const glm::mat4& getProjection() const { return _projection; }

    const glm::mat4& getView() const { return _view; }

    float getWidth() const { return _width; }

    float getHeight() const { return _height; }

    float getFieldOfView() const { return _fieldOfView; }

    float getAspectRatio() const { return _aspectRatio; }

    float getNearClip() const { return _nearClip; }

    float getFarClip() const { return _farClip; }

    float getFocalLength() const { return _focalLength; }


    class Corners {

    public:

        Corners(glm::vec3&& topLeft, glm::vec3&& topRight, glm::vec3&& bottomLeft, glm::vec3&& bottomRight)

            : topLeft{ topLeft }, topRight{ topRight }, bottomLeft{ bottomLeft }, bottomRight{ bottomRight } {}

        glm::vec3 topLeft;

        glm::vec3 topRight;

        glm::vec3 bottomLeft;

        glm::vec3 bottomRight;

    // Get the corners depth units from frustum position, along frustum orientation

    };

    const Corners getCorners(const float depth) const;


    // getters for corners

    const glm::vec3& getFarTopLeft() const { return _cornersWorld[TOP_LEFT_FAR]; }

    const glm::vec3& getFarTopRight() const { return _cornersWorld[TOP_RIGHT_FAR]; }

    const glm::vec3& getFarBottomLeft() const { return _cornersWorld[BOTTOM_LEFT_FAR]; }

    const glm::vec3& getFarBottomRight() const { return _cornersWorld[BOTTOM_RIGHT_FAR]; }

    const glm::vec3& getNearTopLeft() const { return _cornersWorld[TOP_LEFT_NEAR]; }

    const glm::vec3& getNearTopRight() const { return _cornersWorld[TOP_RIGHT_NEAR]; }

    const glm::vec3& getNearBottomLeft() const { return _cornersWorld[BOTTOM_LEFT_NEAR]; }

    const glm::vec3& getNearBottomRight() const { return _cornersWorld[BOTTOM_RIGHT_NEAR]; }


    // get/set for central spherek attribute

    void  setCenterRadius(float radius) { _centerSphereRadius = radius; }

    float getCenterRadius() const { return _centerSphereRadius; }


    void tesselateSides(Triangle triangles[8]) const;

    void tesselateSides(const Transform& transform, Triangle triangles[8]) const;

    void tesselateSidesAndFar(const Transform& transform, Triangle triangles[10], float farDistance) const;


    void calculate();


    typedef enum { OUTSIDE = 0, INTERSECT, INSIDE } intersection;


    ViewFrustum::intersection calculateCubeFrustumIntersection(const AACube& cube) const;

    ViewFrustum::intersection calculateCubeKeyholeIntersection(const AACube& cube) const;


    bool pointIntersectsFrustum(const glm::vec3& point) const;

    bool sphereIntersectsFrustum(const glm::vec3& center, float radius) const;

    bool cubeIntersectsFrustum(const AACube& box) const;

    bool boxIntersectsFrustum(const AABox& box) const;

    bool boxInsideFrustum(const AABox& box) const;


    bool sphereIntersectsKeyhole(const glm::vec3& center, float radius) const;

    bool cubeIntersectsKeyhole(const AACube& cube) const;

    bool boxIntersectsKeyhole(const AABox& box) const;


    bool isVerySimilar(const ViewFrustum& compareTo) const;


    PickRay computePickRay(float x, float y);

    void computePickRay(float x, float y, glm::vec3& origin, glm::vec3& direction) const;


    void computeOffAxisFrustum(float& left, float& right, float& bottom, float& top, float& nearValue, float& farValue,

                               glm::vec4& nearClipPlane, glm::vec4& farClipPlane) const;


    void printDebugDetails() const;


    glm::vec2 projectPoint(glm::vec3 point, bool& pointInView) const;

    CubeProjectedPolygon getProjectedPolygon(const AACube& box) const;

    CubeProjectedPolygon getProjectedPolygon(const AABox& box) const;

    bool getProjectedRect(const AABox& box, glm::vec2& bottomLeft, glm::vec2& topRight) const;

    void getFurthestPointFromCamera(const AACube& box, glm::vec3& furthestPoint) const;


    float distanceToCameraSquared(const glm::vec3& point) const;

    float distanceToCamera(const glm::vec3& point) const { return sqrtf(distanceToCameraSquared(point)); }


    void evalProjectionMatrix(glm::mat4& proj) const;


    glm::mat4 evalProjectionMatrixRange(float rangeNear, float rangeFar) const;


    void evalViewTransform(Transform& view) const;


    enum PlaneIndex { TOP_PLANE = 0, BOTTOM_PLANE, LEFT_PLANE, RIGHT_PLANE, NEAR_PLANE, FAR_PLANE, NUM_PLANES };


    const ::Plane* getPlanes() const { return _planes; }

    void getSidePlanes(::Plane planes[4]) const;

    // Transform can have a different scale value in X,Y,Z components

    void getTransformedSidePlanes(const Transform& transform, ::Plane planes[4]) const;

    // Transform is assumed to have the same scale value in all three X,Y,Z components, which

    // allows for a faster computation.

    void getUniformlyTransformedSidePlanes(const Transform& transform, ::Plane planes[4]) const;


    void invalidate(); // causes all reasonable intersection tests to fail


private:

    glm::mat4 _view;

    glm::mat4 _projection;


    ::Plane _planes[NUM_FRUSTUM_PLANES]; // plane normals point inside frustum


    glm::vec3 _position; // position in world-frame

    glm::quat _orientation; // orientation in world-frame


    // calculated from orientation

    glm::vec3 _direction = IDENTITY_FORWARD;

    glm::vec3 _up = IDENTITY_UP;

    glm::vec3 _right = IDENTITY_RIGHT;


    // calculated from projection

    glm::vec4 _corners[NUM_FRUSTUM_CORNERS];

    glm::vec3 _cornersWorld[NUM_FRUSTUM_CORNERS];

    float _centerSphereRadius = DEFAULT_CENTER_SPHERE_RADIUS;

    float _width { 1.0f };

    float _height { 1.0f };

    float _aspectRatio { 1.0f };

    float _focalLength { 0.25f };

    float _fieldOfView { DEFAULT_FIELD_OF_VIEW_DEGREES };


    float _nearClip { DEFAULT_NEAR_CLIP };

    float _farClip { DEFAULT_FAR_CLIP };


    const char* debugPlaneName (int plane) const;


    // Used to project points

    glm::mat4 _ourModelViewProjectionMatrix;


    template <typename TBOX>

    CubeProjectedPolygon computeProjectedPolygon(const TBOX& box) const;


    static void tesselateSides(const glm::vec3 points[8], Triangle triangles[8]);


};

using ViewFrustumPointer = std::shared_ptr<ViewFrustum>;

using ViewFrustums = std::vector<ViewFrustum>;


#endif // hifi_ViewFrustum_h