Camera.h

#pragma once
 
#include <Core/CoreDLL.h>
#include <Core/World/CoordinateSystem.h>
#include <Foundation/Math/Mat4.h>
#include <Foundation/Reflection/Reflection.h>
#include <Foundation/Types/SharedPtr.h>
#include <Foundation/Types/UniquePtr.h>
 
struct PL_CORE_DLL plCameraMode
{
  using StorageType = plInt8;
 
  enum Enum
  {
    None,                 
    PerspectiveFixedFovX, 
    PerspectiveFixedFovY, 
    OrthoFixedWidth,      
    OrthoFixedHeight,     
    Stereo,               
    Default = PerspectiveFixedFovY
  };
};
 
PL_DECLARE_REFLECTABLE_TYPE(PL_CORE_DLL, plCameraMode);
 
enum class plCameraEye
{
  Left,
  Right,
  // Two eyes should be enough for everyone.
};
 
class PL_CORE_DLL plCamera
{
public:
  plCamera();
 
  void SetCoordinateSystem(plBasisAxis::Enum forwardAxis, plBasisAxis::Enum rightAxis, plBasisAxis::Enum axis);
 
  void SetCoordinateSystem(const plSharedPtr<plCoordinateSystemProvider>& pProvider);
 
  plVec3 GetPosition(plCameraEye eye = plCameraEye::Left) const;
 
  plVec3 GetDirForwards(plCameraEye eye = plCameraEye::Left) const;
 
  plVec3 GetDirUp(plCameraEye eye = plCameraEye::Left) const;
 
  plVec3 GetDirRight(plCameraEye eye = plCameraEye::Left) const;
 
  plAngle GetFovX(float fAspectRatioWidthDivHeight) const;
 
  plAngle GetFovY(float fAspectRatioWidthDivHeight) const;
 
  float GetDimensionX(float fAspectRatioWidthDivHeight) const;
 
  float GetDimensionY(float fAspectRatioWidthDivHeight) const;
 
  plVec3 GetCenterPosition() const;
 
  plVec3 GetCenterDirForwards() const;
 
  plVec3 GetCenterDirUp() const;
 
  plVec3 GetCenterDirRight() const;
 
  float GetNearPlane() const;
 
  float GetFarPlane() const;
 
  void SetCameraMode(plCameraMode::Enum mode, float fFovOrDim, float fNearPlane, float fFarPlane);
 
  void SetStereoProjection(const plMat4& mProjectionLeftEye, const plMat4& mProjectionRightEye, float fAspectRatioWidthDivHeight);
 
  float GetFovOrDim() const;
 
  plCameraMode::Enum GetCameraMode() const;
 
  bool IsPerspective() const;
 
  bool IsOrthographic() const;
 
  bool IsStereoscopic() const;
 
  void SetViewMatrix(const plMat4& mLookAtMatrix, plCameraEye eye = plCameraEye::Left);
 
  void LookAt(const plVec3& vCameraPos, const plVec3& vTargetPos, const plVec3& vUp);
 
  void MoveLocally(float fForward, float fRight, float fUp);
 
  void MoveGlobally(float fForward, float fRight, float fUp);
 
  void RotateLocally(plAngle forwardAxis, plAngle rightAxis, plAngle axis);
 
  void RotateGlobally(plAngle forwardAxis, plAngle rightAxis, plAngle axis);
 
  const plMat4& GetViewMatrix(plCameraEye eye = plCameraEye::Left) const;
 
  void GetProjectionMatrix(float fAspectRatioWidthDivHeight, plMat4& out_mProjectionMatrix, plCameraEye eye = plCameraEye::Left,
    plClipSpaceDepthRange::Enum depthRange = plClipSpaceDepthRange::Default) const;
 
  float GetExposure() const;
  void SetExposure(float fExposure);
 
  float GetAperture() const;
  void SetAperture(float fAperture);
 
  float GetShutterSpeed() const;
  void SetShutterSpeed(float fShutterSpeed);
 
  float GetISO() const;
  void SetISO(float fISO);
 
  float GetFocusDistance() const;
  void SetFocusDistance(float fFocusDistance);
 
  plUInt32 GetSettingsModificationCounter() const { return m_uiSettingsModificationCounter; }
 
  plUInt32 GetOrientationModificationCounter() const { return m_uiOrientationModificationCounter; }
 
private:
  void CameraOrientationChanged(bool bPosition, bool bRotation) { ++m_uiOrientationModificationCounter; }
 
  void CameraSettingsChanged();
 
  void ClampRotationAngles(bool bLocalSpace, plAngle& forwardAxis, plAngle& rightAxis, plAngle& upAxis);
 
  plVec3 InternalGetPosition(plCameraEye eye = plCameraEye::Left) const;
  plVec3 InternalGetDirForwards(plCameraEye eye = plCameraEye::Left) const;
  plVec3 InternalGetDirUp(plCameraEye eye = plCameraEye::Left) const;
  plVec3 InternalGetDirRight(plCameraEye eye = plCameraEye::Left) const;
 
  float m_fNearPlane = 0.1f;
  float m_fFarPlane = 1000.0f;
 
  plCameraMode::Enum m_Mode = plCameraMode::None;
 
  float m_fFovOrDim = 90.0f;
 
  float m_fShutterSpeed = 1.0f;
  float m_fExposure = 1.0f;
  float m_fAperture = 1.0f;
  float m_fISO = 100.0f;
  float m_fFocusDistance = 1.0f;
 
  plVec3 m_vCameraPosition[2];
  plMat4 m_mViewMatrix[2];
 
  float m_fAspectOfPrecomputedStereoProjection = -1.0;
  plMat4 m_mStereoProjectionMatrix[2];
 
  plUInt32 m_uiSettingsModificationCounter = 0;
  plUInt32 m_uiOrientationModificationCounter = 0;
 
  plSharedPtr<plCoordinateSystemProvider> m_pCoordinateSystem;
 
  plVec3 MapExternalToInternal(const plVec3& v) const;
  plVec3 MapInternalToExternal(const plVec3& v) const;
};
 
 
#include <Core/Graphics/Implementation/Camera_inl.h>