Camera Class Reference

#include <camera.h>

Public Member Functions
EIGEN_MAKE_ALIGNED_OPERATOR_NEW	Camera (void)
	Camera (const Camera &other)
virtual	~Camera ()
Camera &	operator= (const Camera &other)
void	setViewport (uint offsetx, uint offsety, uint width, uint height)
void	setViewport (uint width, uint height)
uint	vpX (void) const
uint	vpY (void) const
uint	vpWidth (void) const
uint	vpHeight (void) const
float	fovY (void) const
void	setFovY (float value)
void	setPosition (const Eigen::Vector3f &pos)
const Eigen::Vector3f &	position (void) const
void	setOrientation (const Eigen::Quaternionf &q)
const Eigen::Quaternionf &	orientation (void) const
void	setFrame (const Frame &f)
const Frame &	frame (void) const
void	setDirection (const Eigen::Vector3f &newDirection)
Eigen::Vector3f	direction (void) const
void	setUp (const Eigen::Vector3f &vectorUp)
Eigen::Vector3f	up (void) const
Eigen::Vector3f	right (void) const
void	setTarget (const Eigen::Vector3f &target)
const Eigen::Vector3f &	target (void)
const Eigen::Affine3f &	viewMatrix (void) const
const Eigen::Matrix4f &	projectionMatrix (void) const
void	rotateAroundTarget (const Eigen::Quaternionf &q)
void	localRotate (const Eigen::Quaternionf &q)
void	zoom (float d)
void	localTranslate (const Eigen::Vector3f &t)
void	activateGL (void)
Eigen::Vector3f	unProject (const Eigen::Vector2f &uv, float depth, const Eigen::Matrix4f &invModelview) const
Eigen::Vector3f	unProject (const Eigen::Vector2f &uv, float depth) const

Protected Member Functions
void	updateViewMatrix (void) const
void	updateProjectionMatrix (void) const

Protected Attributes
uint	mVpX
uint	mVpY
uint	mVpWidth
uint	mVpHeight
Frame	mFrame
Eigen::Affine3f	mViewMatrix
Eigen::Matrix4f	mProjectionMatrix
bool	mViewIsUptodate
bool	mProjIsUptodate
Eigen::Vector3f	mTarget
float	mFovY
float	mNearDist
float	mFarDist

Constructor & Destructor Documentation

Camera() [1/2]

Camera::Camera

(

void

)

               : mViewIsUptodate(false), mProjIsUptodate(false) {
  mViewMatrix.setIdentity();
 
  mFovY = M_PI / 3.;
  mNearDist = 1.;
  mFarDist = 50000.;
 
  mVpX = 0;
  mVpY = 0;
 
  setPosition(Vector3f::Constant(100.));
  setTarget(Vector3f::Zero());
}

References M_PI, mFarDist, mFovY, mNearDist, mViewMatrix, mVpX, mVpY, setPosition(), setTarget(), and oomph::PseudoSolidHelper::Zero.

Camera() [2/2]

Camera::Camera

(

const Camera &

other

)

{ *this = other; }

~Camera()

Camera::~Camera ( )

virtual

{}

Member Function Documentation

activateGL()

void Camera::activateGL

(

void

)

Setup OpenGL matrices and viewport

                            {
  glViewport(vpX(), vpY(), vpWidth(), vpHeight());
  gpu.loadMatrix(projectionMatrix(), GL_PROJECTION);
  gpu.loadMatrix(viewMatrix().matrix(), GL_MODELVIEW);
}

References gpu, GpuHelper::loadMatrix(), matrix(), projectionMatrix(), viewMatrix(), vpHeight(), vpWidth(), vpX(), and vpY().

direction()

Vector3f Camera::direction

(

void

)

const

{ return -(orientation() * Vector3f::UnitZ()); }

References orientation().

Referenced by localRotate(), and zoom().

fovY()

float Camera::fovY ( void  ) const

inline

{ return mFovY; }

References mFovY.

frame()

const Frame& Camera::frame ( void  ) const

inline

{ return mFrame; }

References mFrame.

localRotate()

void Camera::localRotate

(

const Eigen::Quaternionf &

q

)

                                             {
  float dist = (position() - mTarget).norm();
  setOrientation(orientation() * q);
  mTarget = position() + dist * direction();
  mViewIsUptodate = false;
}

References direction(), mTarget, mViewIsUptodate, orientation(), position(), Eigen::numext::q, and setOrientation().

localTranslate()

void Camera::localTranslate

(

const Eigen::Vector3f &

t

)

                                             {
  Vector3f trans = orientation() * t;
  setPosition(position() + trans);
  setTarget(mTarget + trans);
 
  mViewIsUptodate = false;
}

References mTarget, mViewIsUptodate, orientation(), position(), setPosition(), setTarget(), plotPSD::t, and trans.

operator=()

Camera & Camera::operator=

(

const Camera &

other

)

                                             {
  mViewIsUptodate = false;
  mProjIsUptodate = false;
 
  mVpX = other.mVpX;
  mVpY = other.mVpY;
  mVpWidth = other.mVpWidth;
  mVpHeight = other.mVpHeight;
 
  mTarget = other.mTarget;
  mFovY = other.mFovY;
  mNearDist = other.mNearDist;
  mFarDist = other.mFarDist;
 
  mViewMatrix = other.mViewMatrix;
  mProjectionMatrix = other.mProjectionMatrix;
 
  return *this;
}

References mFarDist, mFovY, mNearDist, mProjectionMatrix, mProjIsUptodate, mTarget, mViewIsUptodate, mViewMatrix, mVpHeight, mVpWidth, mVpX, and mVpY.

orientation()

const Eigen::Quaternionf& Camera::orientation ( void  ) const

inline

{ return mFrame.orientation; }

References mFrame, and Frame::orientation.

Referenced by direction(), localRotate(), localTranslate(), right(), up(), and updateViewMatrix().

position()

const Eigen::Vector3f& Camera::position ( void  ) const

inline

{ return mFrame.position; }

References mFrame, and Frame::position.

Referenced by localRotate(), localTranslate(), setTarget(), updateViewMatrix(), and zoom().

projectionMatrix()

const Matrix4f & Camera::projectionMatrix

(

void

)

const

                                                   {
  updateProjectionMatrix();
  return mProjectionMatrix;
}

References mProjectionMatrix, and updateProjectionMatrix().

Referenced by activateGL().

right()

Vector3f Camera::right

(

void

)

const

{ return orientation() * Vector3f::UnitX(); }

References orientation().

rotateAroundTarget()

void Camera::rotateAroundTarget

(

const Eigen::Quaternionf &

q

)

                                                    {
  Matrix4f mrot, mt, mtm;
 
  // update the transform matrix
  updateViewMatrix();
  Vector3f t = mViewMatrix * mTarget;
 
  mViewMatrix = Translation3f(t) * q * Translation3f(-t) * mViewMatrix;
 
  Quaternionf qa(mViewMatrix.linear());
  qa = qa.conjugate();
  setOrientation(qa);
  setPosition(-(qa * mViewMatrix.translation()));
 
  mViewIsUptodate = true;
}

References mTarget, mViewIsUptodate, mViewMatrix, Eigen::numext::q, setOrientation(), setPosition(), plotPSD::t, and updateViewMatrix().

setDirection()

void Camera::setDirection

(

const Eigen::Vector3f &

newDirection

)

                                                      {
  // TODO implement it computing the rotation between newDirection and current dir ?
  Vector3f up = this->up();
 
  Matrix3f camAxes;
 
  camAxes.col(2) = (-newDirection).normalized();
  camAxes.col(0) = up.cross(camAxes.col(2)).normalized();
  camAxes.col(1) = camAxes.col(2).cross(camAxes.col(0)).normalized();
  setOrientation(Quaternionf(camAxes));
 
  mViewIsUptodate = false;
}

References mViewIsUptodate, setOrientation(), and up().

Referenced by setTarget().

setFovY()

void Camera::setFovY

(

float

value

)

                                {
  mFovY = value;
  mProjIsUptodate = false;
}

References mFovY, mProjIsUptodate, and Eigen::value.

setFrame()

void Camera::setFrame

(

const Frame &

f

)

                                    {
  mFrame = f;
  mViewIsUptodate = false;
}

References f(), mFrame, and mViewIsUptodate.

setOrientation()

void Camera::setOrientation

(

const Eigen::Quaternionf &

q

)

                                                {
  mFrame.orientation = q;
  mViewIsUptodate = false;
}

References mFrame, mViewIsUptodate, Frame::orientation, and Eigen::numext::q.

Referenced by localRotate(), rotateAroundTarget(), and setDirection().

setPosition()

void Camera::setPosition

(

const Eigen::Vector3f &

pos

)

                                          {
  mFrame.position = p;
  mViewIsUptodate = false;
}

References mFrame, mViewIsUptodate, p, and Frame::position.

Referenced by Camera(), localTranslate(), rotateAroundTarget(), and zoom().

setTarget()

void Camera::setTarget

(

const Eigen::Vector3f &

target

)

                                             {
  mTarget = target;
  if (!mTarget.isApprox(position())) {
    Vector3f newDirection = mTarget - position();
    setDirection(newDirection.normalized());
  }
}

References mTarget, position(), setDirection(), and target().

Referenced by Camera(), and localTranslate().

setUp()

void Camera::setUp

(

const Eigen::Vector3f &

vectorUp

)

setViewport() [1/2]

void Camera::setViewport	(	uint	offsetx,
		uint	offsety,
		uint	width,
		uint	height
	)

                                                                            {
  mVpX = offsetx;
  mVpY = offsety;
  mVpWidth = width;
  mVpHeight = height;
 
  mProjIsUptodate = false;
}

References Global_Physical_Variables::height(), mProjIsUptodate, mVpHeight, mVpWidth, mVpX, and mVpY.

setViewport() [2/2]

void Camera::setViewport	(	uint	width,
		uint	height
	)

                                                {
  mVpWidth = width;
  mVpHeight = height;
 
  mProjIsUptodate = false;
}

References Global_Physical_Variables::height(), mProjIsUptodate, mVpHeight, and mVpWidth.

target()

const Eigen::Vector3f& Camera::target ( void  )

inline

{ return mTarget; }

References mTarget.

Referenced by setTarget().

unProject() [1/2]

Eigen::Vector3f Camera::unProject	(	const Eigen::Vector2f &	uv,
		float	depth
	)		const

unProject() [2/2]

Eigen::Vector3f Camera::unProject	(	const Eigen::Vector2f &	uv,
		float	depth,
		const Eigen::Matrix4f &	invModelview
	)		const

up()

Vector3f Camera::up

(

void

)

const

{ return orientation() * Vector3f::UnitY(); }

References orientation().

Referenced by setDirection().

updateProjectionMatrix()

void Camera::updateProjectionMatrix ( void  ) const

protected

                                              {
  if (!mProjIsUptodate) {
    mProjectionMatrix.setIdentity();
    float aspect = float(mVpWidth) / float(mVpHeight);
    float theta = mFovY * 0.5;
    float range = mFarDist - mNearDist;
    float invtan = 1. / tan(theta);
 
    mProjectionMatrix(0, 0) = invtan / aspect;
    mProjectionMatrix(1, 1) = invtan;
    mProjectionMatrix(2, 2) = -(mNearDist + mFarDist) / range;
    mProjectionMatrix(3, 2) = -1;
    mProjectionMatrix(2, 3) = -2 * mNearDist * mFarDist / range;
    mProjectionMatrix(3, 3) = 0;
 
    mProjIsUptodate = true;
  }
}

References mFarDist, mFovY, mNearDist, mProjectionMatrix, mProjIsUptodate, mVpHeight, mVpWidth, Eigen::bfloat16_impl::tan(), and BiharmonicTestFunctions2::theta.

Referenced by projectionMatrix().

updateViewMatrix()

void Camera::updateViewMatrix ( void  ) const

protected

                                        {
  if (!mViewIsUptodate) {
    Quaternionf q = orientation().conjugate();
    mViewMatrix.linear() = q.toRotationMatrix();
    mViewMatrix.translation() = -(mViewMatrix.linear() * position());
 
    mViewIsUptodate = true;
  }
}

References mViewIsUptodate, mViewMatrix, orientation(), position(), and Eigen::numext::q.

Referenced by rotateAroundTarget(), and viewMatrix().

viewMatrix()

const Affine3f & Camera::viewMatrix

(

void

)

const

                                             {
  updateViewMatrix();
  return mViewMatrix;
}

References mViewMatrix, and updateViewMatrix().

Referenced by activateGL().

vpHeight()

uint Camera::vpHeight ( void  ) const

inline

{ return mVpHeight; }

References mVpHeight.

Referenced by activateGL().

vpWidth()

uint Camera::vpWidth ( void  ) const

inline

{ return mVpWidth; }

References mVpWidth.

Referenced by activateGL().

vpX()

uint Camera::vpX ( void  ) const

inline

{ return mVpX; }

References mVpX.

Referenced by activateGL().

vpY()

uint Camera::vpY ( void  ) const

inline

{ return mVpY; }

References mVpY.

Referenced by activateGL().

zoom()

void Camera::zoom

(

float

d

)

                         {
  float dist = (position() - mTarget).norm();
  if (dist > d) {
    setPosition(position() + direction() * d);
    mViewIsUptodate = false;
  }
}

References direction(), mTarget, mViewIsUptodate, position(), and setPosition().

Member Data Documentation

mFarDist

float Camera::mFarDist

protected

Referenced by Camera(), operator=(), and updateProjectionMatrix().

mFovY

float Camera::mFovY

protected

Referenced by Camera(), fovY(), operator=(), setFovY(), and updateProjectionMatrix().

mFrame

Frame Camera::mFrame

protected

Referenced by frame(), orientation(), position(), setFrame(), setOrientation(), and setPosition().

mNearDist

float Camera::mNearDist

protected

Referenced by Camera(), operator=(), and updateProjectionMatrix().

mProjectionMatrix

Eigen::Matrix4f Camera::mProjectionMatrix

mutableprotected

Referenced by operator=(), projectionMatrix(), and updateProjectionMatrix().

mProjIsUptodate

bool Camera::mProjIsUptodate

mutableprotected

Referenced by operator=(), setFovY(), setViewport(), and updateProjectionMatrix().

mTarget

Eigen::Vector3f Camera::mTarget

protected

Referenced by localRotate(), localTranslate(), operator=(), rotateAroundTarget(), setTarget(), target(), and zoom().

mViewIsUptodate

bool Camera::mViewIsUptodate

mutableprotected

Referenced by localRotate(), localTranslate(), operator=(), rotateAroundTarget(), setDirection(), setFrame(), setOrientation(), setPosition(), updateViewMatrix(), and zoom().

mViewMatrix

Eigen::Affine3f Camera::mViewMatrix

mutableprotected

Referenced by Camera(), operator=(), rotateAroundTarget(), updateViewMatrix(), and viewMatrix().

mVpHeight

uint Camera::mVpHeight

protected

Referenced by operator=(), setViewport(), updateProjectionMatrix(), and vpHeight().

mVpWidth

uint Camera::mVpWidth

protected

Referenced by operator=(), setViewport(), updateProjectionMatrix(), and vpWidth().

mVpX

uint Camera::mVpX

protected

Referenced by Camera(), operator=(), setViewport(), and vpX().

mVpY

uint Camera::mVpY

protected

Referenced by Camera(), operator=(), setViewport(), and vpY().

---

The documentation for this class was generated from the following files:

• camera.h
• camera.cpp