SViewFrustum.h

Go to the documentation of this file.

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
 
#ifndef __SVIEW_FRUSTUM_H_INCLUDED__
#define __SVIEW_FRUSTUM_H_INCLUDED__
 
#include "plane3d.h"
#include "line3d.h"
#include "aabbox3d.h"
 
#include "ETransformStates.h"
#include "GraphicsConstants.h"
#include "enumType.hpp"
#include <glm/vec3.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <array>
 
namespace saga
{
namespace scene
{
 
 
  struct SViewFrustum
  {
    enum class E_PLANES
    {
      FAR,
      NEAR,
      LEFT,
      RIGHT,
      BOTTOM,
      TOP,
    };
 
    SViewFrustum() : BoundingRadius(0.f), FarNearDistance(0.f) {}
 
    SViewFrustum(const SViewFrustum& other);
 
    SViewFrustum(const glm::mat4& mat);
 
    inline void setFrom(const glm::mat4& mat);
 
 
    void transform(const glm::mat4& mat);
 
    glm::vec3 getFarLeftUp() const;
 
    glm::vec3 getFarLeftDown() const;
 
    glm::vec3 getFarRightUp() const;
 
    glm::vec3 getFarRightDown() const;
 
    glm::vec3 getNearLeftUp() const;
 
    glm::vec3 getNearLeftDown() const;
 
    glm::vec3 getNearRightUp() const;
 
    glm::vec3 getNearRightDown() const;
 
    const core::aabbox3d<float> &getBoundingBox() const;
 
    inline void recalculateBoundingBox();
 
    float getBoundingRadius() const;
 
    glm::vec3 getBoundingCenter() const;
 
    void setFarNearDistance(float distance);
 
    glm::mat4& getTransform(video::E_TRANSFORM_STATE state);
 
    const glm::mat4& getTransform(video::E_TRANSFORM_STATE state) const;
 
 
    bool clipLine(core::line3d<float>& line) const;
 
    glm::vec3 cameraPosition;
 
    core::plane3d<float>& plane(E_PLANES type) { return planes[core::enumToPOD(type)]; }
    
    core::plane3d<float> plane(E_PLANES type) const { return planes.at(core::enumToPOD(type)); }
 
    std::array<core::plane3d<float>, VIEW_FRUSTUM_PLANE_COUNT> planes;
 
    core::aabbox3d<float> boundingBox;
 
  private:
    // TODO: port to enum class
    enum class E_TRANSFORM_STATE_FRUSTUM
    {
      VIEW = 0,
      PROJECTION = 1,
    };
 
    inline void recalculateBoundingSphere();
 
    std::array<glm::mat4, TRANSFORM_FRUSTUM_COUNT> Matrices;
 
    float BoundingRadius;
    float FarNearDistance;
    glm::vec3 BoundingCenter;
  };
 
  inline SViewFrustum::SViewFrustum(const SViewFrustum& other)
  {
    cameraPosition=other.cameraPosition;
    boundingBox=other.boundingBox;
 
    std::uint32_t i;
    for (i = 0; i < VIEW_FRUSTUM_PLANE_COUNT; ++i)
      planes[i]=other.planes[i];
 
    for (i = 0; i < TRANSFORM_FRUSTUM_COUNT; ++i)
      Matrices[i]=other.Matrices[i];
 
    BoundingRadius = other.BoundingRadius;
    FarNearDistance = other.FarNearDistance;
    BoundingCenter = other.BoundingCenter;
  }
 
  inline SViewFrustum::SViewFrustum(const glm::mat4& mat)
  {
    setFrom(mat);
  }
 
  inline void SViewFrustum::transform(const glm::mat4& mat)
  {
    for (std::uint32_t i = 0; i < VIEW_FRUSTUM_PLANE_COUNT; ++i)
      planes[i].transform(mat);
 
    cameraPosition = glm::vec4(cameraPosition, 1) * mat;
    recalculateBoundingBox();
  }
 
  inline glm::vec3 SViewFrustum::getFarLeftUp() const
  {
    glm::vec3 p;
    plane(scene::SViewFrustum::E_PLANES::FAR).getIntersectionWithPlanes(
      plane(scene::SViewFrustum::E_PLANES::TOP),
      plane(scene::SViewFrustum::E_PLANES::LEFT), p);
 
    return p;
  }
 
  inline glm::vec3 SViewFrustum::getFarLeftDown() const
  {
    glm::vec3 p;
    plane(scene::SViewFrustum::E_PLANES::FAR).getIntersectionWithPlanes(
      plane(scene::SViewFrustum::E_PLANES::BOTTOM),
      plane(scene::SViewFrustum::E_PLANES::LEFT), p);
 
    return p;
  }
 
  inline glm::vec3 SViewFrustum::getFarRightUp() const
  {
    glm::vec3 p;
    plane(scene::SViewFrustum::E_PLANES::FAR).getIntersectionWithPlanes(
      plane(scene::SViewFrustum::E_PLANES::TOP),
      plane(scene::SViewFrustum::E_PLANES::RIGHT), p);
 
    return p;
  }
 
  inline glm::vec3 SViewFrustum::getFarRightDown() const
  {
    glm::vec3 p;
    plane(scene::SViewFrustum::E_PLANES::FAR).getIntersectionWithPlanes(
      plane(scene::SViewFrustum::E_PLANES::BOTTOM),
      plane(scene::SViewFrustum::E_PLANES::RIGHT), p);
 
    return p;
  }
 
  inline glm::vec3 SViewFrustum::getNearLeftUp() const
  {
    glm::vec3 p;
    plane(scene::SViewFrustum::E_PLANES::NEAR).getIntersectionWithPlanes(
      plane(scene::SViewFrustum::E_PLANES::TOP),
      plane(scene::SViewFrustum::E_PLANES::LEFT), p);
 
    return p;
  }
 
  inline glm::vec3 SViewFrustum::getNearLeftDown() const
  {
    glm::vec3 p;
    plane(scene::SViewFrustum::E_PLANES::NEAR).getIntersectionWithPlanes(
      plane(scene::SViewFrustum::E_PLANES::BOTTOM),
      plane(scene::SViewFrustum::E_PLANES::LEFT), p);
 
    return p;
  }
 
  inline glm::vec3 SViewFrustum::getNearRightUp() const
  {
    glm::vec3 p;
    plane(scene::SViewFrustum::E_PLANES::NEAR).getIntersectionWithPlanes(
      plane(scene::SViewFrustum::E_PLANES::TOP),
      plane(scene::SViewFrustum::E_PLANES::RIGHT), p);
 
    return p;
  }
 
  inline glm::vec3 SViewFrustum::getNearRightDown() const
  {
    glm::vec3 p;
    plane(scene::SViewFrustum::E_PLANES::NEAR).getIntersectionWithPlanes(
      plane(scene::SViewFrustum::E_PLANES::BOTTOM),
      plane(scene::SViewFrustum::E_PLANES::RIGHT), p);
 
    return p;
  }
 
  inline const core::aabbox3d<float> &SViewFrustum::getBoundingBox() const
  {
    return boundingBox;
  }
 
  inline void SViewFrustum::recalculateBoundingBox()
  {
    boundingBox.reset (cameraPosition);
 
    boundingBox.addInternalPoint(getFarLeftUp());
    boundingBox.addInternalPoint(getFarRightUp());
    boundingBox.addInternalPoint(getFarLeftDown());
    boundingBox.addInternalPoint(getFarRightDown());
 
    // Also recalculate the bounding sphere when the bbox changes
    recalculateBoundingSphere();
  }
 
  inline float SViewFrustum::getBoundingRadius() const
  {
    return BoundingRadius;
  }
 
  inline glm::vec3 SViewFrustum::getBoundingCenter() const
  {
    return BoundingCenter;
  }
 
  inline void SViewFrustum::setFarNearDistance(float distance)
  {
    FarNearDistance = distance;
  }
 
  inline void SViewFrustum::setFrom(const glm::mat4& matrix)
  {
    // left clipping plane
    auto mat = glm::value_ptr(matrix);
    plane(E_PLANES::LEFT).Normal.x = mat[3 ] + mat[0];
    plane(E_PLANES::LEFT).Normal.y = mat[7 ] + mat[4];
    plane(E_PLANES::LEFT).Normal.z = mat[11] + mat[8];
    plane(E_PLANES::LEFT).D =        mat[15] + mat[12];
 
    // right clipping plane
    plane(E_PLANES::RIGHT).Normal.x = mat[3 ] - mat[0];
    plane(E_PLANES::RIGHT).Normal.y = mat[7 ] - mat[4];
    plane(E_PLANES::RIGHT).Normal.z = mat[11] - mat[8];
    plane(E_PLANES::RIGHT).D =        mat[15] - mat[12];
 
    // top clipping plane
    plane(E_PLANES::TOP).Normal.x = mat[3 ] - mat[1];
    plane(E_PLANES::TOP).Normal.y = mat[7 ] - mat[5];
    plane(E_PLANES::TOP).Normal.z = mat[11] - mat[9];
    plane(E_PLANES::TOP).D =        mat[15] - mat[13];
 
    // bottom clipping plane
    plane(E_PLANES::BOTTOM).Normal.x = mat[3 ] + mat[1];
    plane(E_PLANES::BOTTOM).Normal.y = mat[7 ] + mat[5];
    plane(E_PLANES::BOTTOM).Normal.z = mat[11] + mat[9];
    plane(E_PLANES::BOTTOM).D =        mat[15] + mat[13];
 
    // far clipping plane
    plane(E_PLANES::FAR).Normal.x = mat[3 ] - mat[2];
    plane(E_PLANES::FAR).Normal.y = mat[7 ] - mat[6];
    plane(E_PLANES::FAR).Normal.z = mat[11] - mat[10];
    plane(E_PLANES::FAR).D =        mat[15] - mat[14];
 
    // near clipping plane
    plane(E_PLANES::NEAR).Normal.x = mat[2];
    plane(E_PLANES::NEAR).Normal.y = mat[6];
    plane(E_PLANES::NEAR).Normal.z = mat[10];
    plane(E_PLANES::NEAR).D =        mat[14];
 
    // normalize normals
    std::uint32_t i;
    for (i = 0; i != VIEW_FRUSTUM_PLANE_COUNT; ++i)
    {
      const float len = -core::reciprocal_squareroot(glm::length2(planes[i].Normal));
      planes[i].Normal *= len;
      planes[i].D *= len;
    }
 
    // make bounding box
    recalculateBoundingBox();
  }
 
  inline glm::mat4& SViewFrustum::getTransform(video::E_TRANSFORM_STATE state)
  {
    return Matrices[core::enumToPOD(state)];
  }
 
  inline const glm::mat4& SViewFrustum::getTransform(video::E_TRANSFORM_STATE state) const
  {
    return Matrices.at(core::enumToPOD(state));
  }
 
  inline bool SViewFrustum::clipLine(core::line3d<float>& line) const
  {
    bool wasClipped = false;
    for (std::uint32_t i = 0; i < VIEW_FRUSTUM_PLANE_COUNT; ++i)
    {
      if (planes[i].classifyPointRelation(line.start) == core::ISREL3D_FRONT)
      {
        line.start = glm::mix(line.start, line.end,
          planes[i].getKnownIntersectionWithLine(line.start, line.end)
        );
        wasClipped = true;
      }
      if (planes[i].classifyPointRelation(line.end) == core::ISREL3D_FRONT)
      {
        line.end = glm::mix(line.start, line.end,
          planes[i].getKnownIntersectionWithLine(line.start, line.end)
        );
        wasClipped = true;
      }
    }
    return wasClipped;
  }
 
  inline void SViewFrustum::recalculateBoundingSphere()
  {
    // Find the center
    const float shortlen = glm::length(getNearLeftUp() - getNearRightUp());
    const float longlen = glm::length(getFarLeftUp() - getFarRightUp());
 
    const float farlen = FarNearDistance;
    const float fartocenter = (farlen + (shortlen - longlen) * (shortlen + longlen)/(4*farlen)) / 2;
    const float neartocenter = farlen - fartocenter;
 
    BoundingCenter = cameraPosition + -plane(E_PLANES::NEAR).Normal * neartocenter;
 
    // Find the radius
    glm::vec3 dir[8];
    dir[0] = getFarLeftUp() - BoundingCenter;
    dir[1] = getFarRightUp() - BoundingCenter;
    dir[2] = getFarLeftDown() - BoundingCenter;
    dir[3] = getFarRightDown() - BoundingCenter;
    dir[4] = getNearRightDown() - BoundingCenter;
    dir[5] = getNearLeftDown() - BoundingCenter;
    dir[6] = getNearRightUp() - BoundingCenter;
    dir[7] = getNearLeftUp() - BoundingCenter;
 
    std::uint32_t i = 0;
    float diam[8] = { 0.f };
 
    for (i = 0; i < 8; ++i)
      diam[i] = glm::length2(dir[i]);
 
    float longest = 0;
 
    for (i = 0; i < 8; ++i)
    {
      if (diam[i] > longest)
        longest = diam[i];
    }
 
    BoundingRadius = sqrtf(longest);
  }
 
} // namespace scene
} // namespace saga
 
#endif