Camera.h

Go to the documentation of this file.

//============================================================================
//  The contents of this file are covered by the Viskores license. See
//  LICENSE.txt for details.
//
//  By contributing to this file, all contributors agree to the Developer
//  Certificate of Origin Version 1.1 (DCO 1.1) as stated in DCO.txt.
//============================================================================
 
//============================================================================
//  Copyright (c) Kitware, Inc.
//  All rights reserved.
//  See LICENSE.txt for details.
//
//  This software is distributed WITHOUT ANY WARRANTY; without even
//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
//  PURPOSE.  See the above copyright notice for more information.
//============================================================================
#ifndef viskores_rendering_Camera_h
#define viskores_rendering_Camera_h
 
#include <viskores/rendering/viskores_rendering_export.h>
 
#include <viskores/Bounds.h>
#include <viskores/Math.h>
#include <viskores/Matrix.h>
#include <viskores/Range.h>
#include <viskores/Transform3D.h>
#include <viskores/VectorAnalysis.h>
#include <viskores/rendering/MatrixHelpers.h>
 
namespace viskores
{
namespace rendering
{
 
class VISKORES_RENDERING_EXPORT Camera
{
  struct Camera3DStruct
  {
  public:
    VISKORES_CONT
    Camera3DStruct()
      : LookAt(0.0f, 0.0f, 0.0f)
      , Position(0.0f, 0.0f, 1.0f)
      , ViewUp(0.0f, 1.0f, 0.0f)
      , FieldOfView(60.0f)
      , XPan(0.0f)
      , YPan(0.0f)
      , Zoom(1.0f)
    {
    }
 
    viskores::Matrix<viskores::Float32, 4, 4> CreateViewMatrix() const;
 
    viskores::Matrix<viskores::Float32, 4, 4> CreateProjectionMatrix(
      viskores::Id width,
      viskores::Id height,
      viskores::Float32 nearPlane,
      viskores::Float32 farPlane) const;
 
    viskores::Vec3f_32 LookAt;
    viskores::Vec3f_32 Position;
    viskores::Vec3f_32 ViewUp;
    viskores::Float32 FieldOfView;
    viskores::Float32 XPan;
    viskores::Float32 YPan;
    viskores::Float32 Zoom;
  };
 
  struct VISKORES_RENDERING_EXPORT Camera2DStruct
  {
  public:
    VISKORES_CONT
    Camera2DStruct()
      : Left(-1.0f)
      , Right(1.0f)
      , Bottom(-1.0f)
      , Top(1.0f)
      , XScale(1.0f)
      , XPan(0.0f)
      , YPan(0.0f)
      , Zoom(1.0f)
    {
    }
 
    viskores::Matrix<viskores::Float32, 4, 4> CreateViewMatrix() const;
 
    viskores::Matrix<viskores::Float32, 4, 4> CreateProjectionMatrix(
      viskores::Float32 size,
      viskores::Float32 znear,
      viskores::Float32 zfar,
      viskores::Float32 aspect) const;
 
    viskores::Float32 Left;
    viskores::Float32 Right;
    viskores::Float32 Bottom;
    viskores::Float32 Top;
    viskores::Float32 XScale;
    viskores::Float32 XPan;
    viskores::Float32 YPan;
    viskores::Float32 Zoom;
  };
 
public:
  enum struct Mode
  {
    TwoD,
    ThreeD,
  };
 
  VISKORES_CONT
  Camera(Mode vtype = Camera::Mode::ThreeD)
    : ModeType(vtype)
    , NearPlane(0.01f)
    , FarPlane(1000.0f)
    , ViewportLeft(-1.0f)
    , ViewportRight(1.0f)
    , ViewportBottom(-1.0f)
    , ViewportTop(1.0f)
  {
  }
 
  viskores::Matrix<viskores::Float32, 4, 4> CreateViewMatrix() const;
 
  viskores::Matrix<viskores::Float32, 4, 4> CreateProjectionMatrix(viskores::Id screenWidth,
                                                                   viskores::Id screenHeight) const;
 
  void GetRealViewport(viskores::Id screenWidth,
                       viskores::Id screenHeight,
                       viskores::Float32& left,
                       viskores::Float32& right,
                       viskores::Float32& bottom,
                       viskores::Float32& top) const;
 
  VISKORES_CONT
  viskores::rendering::Camera::Mode GetMode() const { return this->ModeType; }
  VISKORES_CONT
  void SetMode(viskores::rendering::Camera::Mode mode) { this->ModeType = mode; }
  VISKORES_CONT
  void SetModeTo3D() { this->SetMode(viskores::rendering::Camera::Mode::ThreeD); }
  VISKORES_CONT
  void SetModeTo2D() { this->SetMode(viskores::rendering::Camera::Mode::TwoD); }
 
  VISKORES_CONT
  viskores::Range GetClippingRange() const
  {
    return viskores::Range(this->NearPlane, this->FarPlane);
  }
  VISKORES_CONT
  void SetClippingRange(viskores::Float32 nearPlane, viskores::Float32 farPlane)
  {
    this->NearPlane = nearPlane;
    this->FarPlane = farPlane;
  }
  VISKORES_CONT
  void SetClippingRange(viskores::Float64 nearPlane, viskores::Float64 farPlane)
  {
    this->SetClippingRange(static_cast<viskores::Float32>(nearPlane),
                           static_cast<viskores::Float32>(farPlane));
  }
  VISKORES_CONT
  void SetClippingRange(const viskores::Range& nearFarRange)
  {
    this->SetClippingRange(nearFarRange.Min, nearFarRange.Max);
  }
 
  VISKORES_CONT
  void GetViewport(viskores::Float32& left,
                   viskores::Float32& right,
                   viskores::Float32& bottom,
                   viskores::Float32& top) const
  {
    left = this->ViewportLeft;
    right = this->ViewportRight;
    bottom = this->ViewportBottom;
    top = this->ViewportTop;
  }
  VISKORES_CONT
  void GetViewport(viskores::Float64& left,
                   viskores::Float64& right,
                   viskores::Float64& bottom,
                   viskores::Float64& top) const
  {
    left = this->ViewportLeft;
    right = this->ViewportRight;
    bottom = this->ViewportBottom;
    top = this->ViewportTop;
  }
  VISKORES_CONT
  viskores::Bounds GetViewport() const
  {
    return viskores::Bounds(
      this->ViewportLeft, this->ViewportRight, this->ViewportBottom, this->ViewportTop, 0.0, 0.0);
  }
  VISKORES_CONT
  void SetViewport(viskores::Float32 left,
                   viskores::Float32 right,
                   viskores::Float32 bottom,
                   viskores::Float32 top)
  {
    this->ViewportLeft = left;
    this->ViewportRight = right;
    this->ViewportBottom = bottom;
    this->ViewportTop = top;
  }
  VISKORES_CONT
  void SetViewport(viskores::Float64 left,
                   viskores::Float64 right,
                   viskores::Float64 bottom,
                   viskores::Float64 top)
  {
    this->SetViewport(static_cast<viskores::Float32>(left),
                      static_cast<viskores::Float32>(right),
                      static_cast<viskores::Float32>(bottom),
                      static_cast<viskores::Float32>(top));
  }
  VISKORES_CONT
  void SetViewport(const viskores::Bounds& viewportBounds)
  {
    this->SetViewport(
      viewportBounds.X.Min, viewportBounds.X.Max, viewportBounds.Y.Min, viewportBounds.Y.Max);
  }
 
  VISKORES_CONT
  const viskores::Vec3f_32& GetLookAt() const { return this->Camera3D.LookAt; }
  VISKORES_CONT
  void SetLookAt(const viskores::Vec3f_32& lookAt)
  {
    this->SetModeTo3D();
    this->Camera3D.LookAt = lookAt;
  }
  VISKORES_CONT
  void SetLookAt(const viskores::Vec<Float64, 3>& lookAt)
  {
    this->SetLookAt(viskores::Vec<Float32, 3>(lookAt));
  }
 
  VISKORES_CONT
  const viskores::Vec3f_32& GetPosition() const { return this->Camera3D.Position; }
  VISKORES_CONT
  void SetPosition(const viskores::Vec3f_32& position)
  {
    this->SetModeTo3D();
    this->Camera3D.Position = position;
  }
  VISKORES_CONT
  void SetPosition(const viskores::Vec3f_64& position)
  {
    this->SetPosition(viskores::Vec3f_32(position));
  }
 
  VISKORES_CONT
  const viskores::Vec3f_32& GetViewUp() const { return this->Camera3D.ViewUp; }
  VISKORES_CONT
  void SetViewUp(const viskores::Vec3f_32& viewUp)
  {
    this->SetModeTo3D();
    this->Camera3D.ViewUp = viewUp;
  }
  VISKORES_CONT
  void SetViewUp(const viskores::Vec3f_64& viewUp) { this->SetViewUp(viskores::Vec3f_32(viewUp)); }
 
  VISKORES_CONT
  viskores::Float32 GetXScale() const { return this->Camera2D.XScale; }
  VISKORES_CONT
  void SetXScale(viskores::Float32 xscale)
  {
    this->SetModeTo2D();
    this->Camera2D.XScale = xscale;
  }
  VISKORES_CONT
  void SetXScale(viskores::Float64 xscale)
  {
    this->SetXScale(static_cast<viskores::Float32>(xscale));
  }
 
  VISKORES_CONT
  viskores::Float32 GetFieldOfView() const { return this->Camera3D.FieldOfView; }
  VISKORES_CONT
  void SetFieldOfView(viskores::Float32 fov)
  {
    this->SetModeTo3D();
    this->Camera3D.FieldOfView = fov;
  }
  VISKORES_CONT
  void SetFieldOfView(viskores::Float64 fov)
  {
    this->SetFieldOfView(static_cast<viskores::Float32>(fov));
  }
 
  void Pan(viskores::Float32 dx, viskores::Float32 dy);
  VISKORES_CONT
  void Pan(viskores::Float64 dx, viskores::Float64 dy)
  {
    this->Pan(static_cast<viskores::Float32>(dx), static_cast<viskores::Float32>(dy));
  }
  VISKORES_CONT
  void Pan(viskores::Vec2f_32 direction) { this->Pan(direction[0], direction[1]); }
  VISKORES_CONT
  void Pan(viskores::Vec2f_64 direction) { this->Pan(direction[0], direction[1]); }
  VISKORES_CONT
  viskores::Vec2f_32 GetPan() const
  {
    viskores::Vec2f_32 pan;
    // Note that the 2D and 3D pan are always set the same.
    pan[0] = this->Camera3D.XPan;
    pan[1] = this->Camera3D.YPan;
    return pan;
  }
 
 
  void Zoom(viskores::Float32 zoom);
  VISKORES_CONT
  void Zoom(viskores::Float64 zoom) { this->Zoom(static_cast<viskores::Float32>(zoom)); }
  VISKORES_CONT
  viskores::Float32 GetZoom() const { return this->Camera3D.Zoom; }
 
  void TrackballRotate(viskores::Float32 startX,
                       viskores::Float32 startY,
                       viskores::Float32 endX,
                       viskores::Float32 endY);
  VISKORES_CONT
  void TrackballRotate(viskores::Float64 startX,
                       viskores::Float64 startY,
                       viskores::Float64 endX,
                       viskores::Float64 endY)
  {
    this->TrackballRotate(static_cast<viskores::Float32>(startX),
                          static_cast<viskores::Float32>(startY),
                          static_cast<viskores::Float32>(endX),
                          static_cast<viskores::Float32>(endY));
  }
 
  void ResetToBounds(const viskores::Bounds& dataBounds);
  void ResetToBounds(const viskores::Bounds& dataBounds, viskores::Float64 dataViewPadding);
  void ResetToBounds(const viskores::Bounds& dataBounds,
                     viskores::Float64 XDataViewPadding,
                     viskores::Float64 YDataViewPadding,
                     viskores::Float64 ZDataViewPadding);
 
  void Roll(viskores::Float32 angleDegrees);
  VISKORES_CONT
  void Roll(viskores::Float64 angleDegrees)
  {
    this->Roll(static_cast<viskores::Float32>(angleDegrees));
  }
 
  void Azimuth(viskores::Float32 angleDegrees);
  VISKORES_CONT
  void Azimuth(viskores::Float64 angleDegrees)
  {
    this->Azimuth(static_cast<viskores::Float32>(angleDegrees));
  }
 
  void Elevation(viskores::Float32 angleDegrees);
  VISKORES_CONT
  void Elevation(viskores::Float64 angleDegrees)
  {
    this->Elevation(static_cast<viskores::Float32>(angleDegrees));
  }
 
  void Dolly(viskores::Float32 value);
  VISKORES_CONT
  void Dolly(viskores::Float64 value) { this->Dolly(static_cast<viskores::Float32>(value)); }
 
  VISKORES_CONT
  void GetViewRange2D(viskores::Float32& left,
                      viskores::Float32& right,
                      viskores::Float32& bottom,
                      viskores::Float32& top) const
  {
    left = this->Camera2D.Left;
    right = this->Camera2D.Right;
    bottom = this->Camera2D.Bottom;
    top = this->Camera2D.Top;
  }
  VISKORES_CONT
  viskores::Bounds GetViewRange2D() const
  {
    return viskores::Bounds(this->Camera2D.Left,
                            this->Camera2D.Right,
                            this->Camera2D.Bottom,
                            this->Camera2D.Top,
                            0.0,
                            0.0);
  }
  VISKORES_CONT
  void SetViewRange2D(viskores::Float32 left,
                      viskores::Float32 right,
                      viskores::Float32 bottom,
                      viskores::Float32 top)
  {
    this->SetModeTo2D();
    this->Camera2D.Left = left;
    this->Camera2D.Right = right;
    this->Camera2D.Bottom = bottom;
    this->Camera2D.Top = top;
 
    this->Camera2D.XPan = 0;
    this->Camera2D.YPan = 0;
    this->Camera2D.Zoom = 1;
  }
  VISKORES_CONT
  void SetViewRange2D(viskores::Float64 left,
                      viskores::Float64 right,
                      viskores::Float64 bottom,
                      viskores::Float64 top)
  {
    this->SetViewRange2D(static_cast<viskores::Float32>(left),
                         static_cast<viskores::Float32>(right),
                         static_cast<viskores::Float32>(bottom),
                         static_cast<viskores::Float32>(top));
  }
  VISKORES_CONT
  void SetViewRange2D(const viskores::Range& xRange, const viskores::Range& yRange)
  {
    this->SetViewRange2D(xRange.Min, xRange.Max, yRange.Min, yRange.Max);
  }
  VISKORES_CONT
  void SetViewRange2D(const viskores::Bounds& viewRange)
  {
    this->SetViewRange2D(viewRange.X, viewRange.Y);
  }
 
  VISKORES_CONT
  void Print() const;
 
private:
  Mode ModeType;
  Camera3DStruct Camera3D;
  Camera2DStruct Camera2D;
 
  viskores::Float32 NearPlane;
  viskores::Float32 FarPlane;
 
  viskores::Float32 ViewportLeft;
  viskores::Float32 ViewportRight;
  viskores::Float32 ViewportBottom;
  viskores::Float32 ViewportTop;
};
}
} // namespace viskores::rendering
 
#endif // viskores_rendering_Camera_h