自学教程：C++ updateViewMatrix函数代码示例

void Camera::rotate(float angle, const Vector3& axis){	Matrix44 R;	R.setRotation(angle,axis);	Vector3 new_front = R * (center - eye);	center = eye + new_front;	updateViewMatrix();}

void Camera::setAxes(const Vec3& right, const Vec3& up, const Vec3& front) {    m_right = right;    m_up = up;    m_front = front;    updateViewMatrix();    updateViewProjectionMatrix();	updateFrustumPlanesAndPoints();}

    // updates only if needed    const Mat44& Camera::getViewMatrix()    {        if (mMatrixUpdateFlags) {            updateViewMatrix();        }        return mViewMatrix;    }

void Camera::Lookat(Mesh* mesh){    unsigned int mid_index = mesh->vertex_number_/2;    EigenVector3 lookat = mesh->vec_current_position_.block_vector(mid_index);    m_lookat = glm::vec3(lookat[0], lookat[1], lookat[2]);    updateViewMatrix();}

void Camera::onLateUpdate(){	if (dImpl->dirty)	{		updateViewMatrix();		dImpl->dirty = false;	}}

	void ShadowManager::addShadowLight(Light *const light)	{		light->addObserver(this, Light::MOVE);		shadowDatas[light] = new ShadowData(light, nbShadowMaps);		createShadowMaps(light);		updateViewMatrix(light);	}

void CCAMERA::ResetXYpos(){    m_parametersChanged = true;    m_camera_pos.x = 0.0f;    m_camera_pos.y = 0.0f;    updateViewMatrix();    updateFrustum();}

void Camera::MouseChangeLookat(float coe, float dx, float dy){    glm::vec3 vdir(m_lookat - m_position);    glm::vec3 u(glm::normalize(glm::cross(vdir, m_up)));    glm::vec3 v(glm::normalize(glm::cross(u, vdir)));    m_lookat += coe * (dy * v - dx * u);    updateViewMatrix();}

const Matrix4& Camera::getViewMatrix(){    if (m_isMatViewDirty) {        updateViewMatrix();        m_isMatViewDirty = false;    }        return m_matView;}

CWBOOL cwOrthoCamera::init(){	if (!cwCamera::init()) return CWFALSE;	m_nPos = cwVector3D(0.0f, 0.0f, -10.0f);	updateViewMatrix();	return CWTRUE;}

	void ShadowManager::onResize(int width, int height)	{		sceneWidth = width;		sceneHeight = height;		for(std::map<const Light *, ShadowData *>::const_iterator it = shadowDatas.begin(); it!=shadowDatas.end(); ++it)		{			updateViewMatrix(it->first);		}	}

 /**  * @brief Resets trackball to initial position and orientation  */ void reset (void) {     quaternion = Eigen::Quaternion<float>::Identity();     zoom = 1.0;     translationVector << 0.0, 0.0, 0.0;     rotating = false;     translating = false;     Camera::reset();     updateViewMatrix(); }

	/**	*	Set the position at which the camera is looking and update its rendering matrices accordingly	*	@author Serge Radinovich	*	@param  _pTarget		New target of the camera	*/	void Camera::lookAt(const D3DXVECTOR3*  _pTarget)	{		m_lookPos = *_pTarget;		D3DXVECTOR3 _look = m_lookPos - m_transform.translation;		D3DXVec3Normalize(&_look, &_look);		Transform::setForward(&m_transform, &_look);		updateViewMatrix();	}

void updateEditorCamera(void){	camera_struct* c=&editorCamera;	c->viewPosition=c->position;		updateViewMatrix(c);	updateFrustum(c);		fixMatrix(c->transformationMatrix);}

    /**     * @brief Resets camera to initial position and orientation     */    void reset (void) override    {		start_mouse_pos = Eigen::Vector2f::Zero();		rotation_matrix = Eigen::Matrix3f::Identity();		default_translation = Eigen::Vector3f (0.0, 0.0, -2.0);		translation_vector = default_translation;        rotation_X_axis = 0.0;        rotation_Y_axis = 0.0;		rotation_Z_axis = 0.0;		updateViewMatrix();    }

void Camera::set(){	updateViewMatrix();	updateProjectionMatrix();	glMatrixMode( GL_MODELVIEW );	glLoadMatrixf( view_matrix.m );	glMatrixMode( GL_PROJECTION );	glLoadMatrixf( projection_matrix.m );	glMatrixMode( GL_MODELVIEW );}

Camera::Camera(vec3 pos, float horiAngle, float vertAngle, float aspectRatio, float fovy, float viewDistance) :	position(pos){	this->verticalAngle = vertAngle;	this->horizontalAngle = horiAngle;	this->aspect = aspectRatio;	this->fovy = fovy;	this->viewDistance = viewDistance;	updateViewMatrix();	updateProjectionMatrix();}

void Camera::move(const D3DXVECTOR3 &direction, const D3DXVECTOR3 &amount){    // Moves the camera by the specified amount of world units in the specified    // direction in world space.    m_eye.x += direction.x * amount.x;    m_eye.y += direction.y * amount.y;    m_eye.z += direction.z * amount.z;    updateViewMatrix(false);}

void DeferredRendererOld::refresh(){  if(shader_->isModified())    updateShader();  mesh_.refresh();  sceneBox_.refresh();  camera_->update();  quadRender_.refresh();  updateViewMatrix();}

///////////////////////////////////////////////////////////////////////////////// set the camera position and rotation///////////////////////////////////////////////////////////////////////////////void ModelGL::setViewMatrix(float x, float y, float z, float pitch, float heading, float roll){    cameraPosition[0] = x;    cameraPosition[1] = y;    cameraPosition[2] = z;    cameraAngle[0] = pitch;    cameraAngle[1] = heading;    cameraAngle[2] = roll;    updateViewMatrix();}

    void rotate(const glm::vec2& delta) {        // create orientation vectors        auto lookat = orientation * Vectors::UNIT_NEG_Z;        auto forward = glm::normalize(vec3(lookat.x, 0, lookat.z));        auto side = glm::cross(Vectors::UP, forward);        // rotate camera with quaternions created from axis and angle        orientation = glm::angleAxis(delta.x, Vectors::UP) * orientation;        orientation = glm::angleAxis(-delta.y, side) * orientation;        updateViewMatrix();    }

CWVOID cwCamera::lookAt(const cwVector3D& pos, const cwVector3D& target, const cwVector3D& up){	m_nLook = target - pos;	m_nLook.normalize();	m_nRight = up.cross(m_nLook);	m_nRight.normalize();	m_nUp = m_nLook.cross(m_nRight);		m_nPos = pos;	updateViewMatrix();}

Camera::Camera(GLFWwindow *window) {	m_window = window;	getWindowDimensions();	centerMouse();	initVars();	setCenter(glm::vec3(0, 0, 5));	setLookAt(glm::vec3(0, 0, 4));	setUp(glm::vec3(0, 1, 0));	setRight(glm::vec3(1, 0, 0));	updateViewMatrix();}

xtCamera::xtCamera(void){	//this->matrixView.identity();	for ( int i=0; i<3; ++i ) {		this->cameraPosition[i] = 0.0;	}	this->cameraAngle[0] = CAMERA_ANGLE_X;	this->cameraAngle[1] = CAMERA_ANGLE_Y;	this->cameraAngle[2] = 0.0f;	updateViewMatrix();}

	void ShadowManager::notify(Observable *observable, int notificationType)	{		if(dynamic_cast<LightManager *>(observable))		{			Light *light = lightManager->getLastUpdatedLight();			switch(notificationType)			{				case LightManager::ADD_LIGHT:				{					light->addObserver(this, Light::PRODUCE_SHADOW);					if(light->isProduceShadow())					{						addShadowLight(light);					}					break;				}				case LightManager::REMOVE_LIGHT:				{					light->removeObserver(this, Light::PRODUCE_SHADOW);					if(light->isProduceShadow())					{						removeShadowLight(light);					}					break;				}			}		}else if(Light *light = dynamic_cast<Light *>(observable))		{			switch(notificationType)			{				case Light::MOVE:				{					updateViewMatrix(light);					break;				}				case Light::PRODUCE_SHADOW:				{					if(light->isProduceShadow())					{						addShadowLight(light);					}else					{						removeShadowLight(light);					}					break;				}			}		}	}

void Camera::orbit( const Vector3& center, float angle, const Vector3& axis ){	Matrix44 R;	R.setRotation(angle,axis);	Matrix44 T;	T.setTranslation( center.x, center.y, center.z );	Matrix44 M = T * R;	T.setTranslation( -center.x, -center.y, -center.z );	M = M * T;	this->center = M * this->center;	this->eye = M * this->eye;	updateViewMatrix();}