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

void PlotCartesianWidget::mouseMoveEvent(QMouseEvent *event){    int dx = event->x() - lastPos.x();    int dy = event->y() - lastPos.y();    // control+left adjusts the x-scale of the graph    if( event->buttons() & Qt::LeftButton && event->modifiers() & Qt::ControlModifier )    {        int d = abs(dx) > abs(dy) ? dx : dy;        scaleX += float(d) * scaleX * 0.05;        scaleX = std::max<float>( scaleX, 0.01 );        scaleX = std::min<float>( scaleX, 50.0 );        updateInputDataLineVAO();        updateViewMatrix();    }    // control+right adjusts the x-scale of the graph    else if( event->buttons() & Qt::RightButton && event->modifiers() & Qt::ControlModifier )    {        int d = abs(dx) > abs(dy) ? dx : dy;        scaleY += float(d) * scaleY * 0.05;        scaleY = std::max<float>( scaleY, 0.01 );        scaleY = std::min<float>( scaleY, 50.0 );        updateAxisVAO();        updateViewMatrix();    }    // left mouse button adjusts the viewing dir    else if (event->buttons() & Qt::LeftButton)    {        float xScalar = 1.0 / float(width()*devicePixelRatio());        float yScalar = 1.0 / float(height()*devicePixelRatio());        float maxScalar = std::max( xScalar, yScalar );        centerX += float(-dx)*maxScalar*2.0*lookZoom;        centerY += float( dy)*maxScalar*2.0*lookZoom;        updateProjectionMatrix();        updateInputDataLineVAO();    }    // right mouse button adjusts the zoom    else if (event->buttons() & Qt::RightButton)    {        // use the dir with the biggest change        int d = abs(dx) > abs(dy) ? dx : dy;        lookZoom -= float(d) * lookZoom * 0.05;        lookZoom = std::max<float>( lookZoom, 0.01f );        lookZoom = std::min<float>( lookZoom, 50.0f );        updateAxisVAO();        updateInputDataLineVAO();        updateProjectionMatrix();    }    lastPos = event->pos();    // redraw    updateGL();}

void QGLView::updatePerspectiveAspectRatio(){    qreal ratio;    int w;    int h;    if (window() != NULL) {        ratio = window()->devicePixelRatio();    }    else {        ratio = 1.0f;    }    w = int(ratio * this->width());    h = int(ratio * this->height());    if ((w > 0) && (h > 0)) // avoid division by zero    {        m_projectionAspectRatio = (float)w/(float)h;    }    else {        m_projectionAspectRatio = 1.0f;    }    updateProjectionMatrix();}

void CamtransCamera::setAspectRatio(float a){    // @TODO: [CAMTRANS] Fill this in...    m_aspectRatio = a;    updateProjectionMatrix();}

Camera::Camera(const Type& type): m_type(type), m_position(Vec3::zero), m_right(Vec3::xxx), m_up(Vec3::yyy), m_front(Vec3::zzz), m_upFovDegrees(0.0f), m_aspectRatio(0.0f), m_rightMin(0.0f), m_rightMax(0.0f), m_upMin(0.0f), m_upMax(0.0f), m_frontMin(0.0f), m_frontMax(0.0f), m_preViewMatrix(Mat4::identity), m_viewMatrix(Mat4::identity), m_orthographicProjectionMatrix(Mat4::identity), m_perspectiveProjectionMatrix(Mat4::identity), m_viewOrthographicProjectionMatrix(Mat4::identity), m_viewPerspectiveProjectionMatrix(Mat4::identity), m_postProjectionMatrix(Mat4::identity) {    updateViewMatrix();    updateProjectionMatrix();    updateViewProjectionMatrix();	updateFrustumPlanesAndPoints();}

// resizevoid Camera::ResizeWindow(int w, int h){    this->m_width = w;    this->m_height = h;    updateProjectionMatrix();}

void Projector::update(){    if(!m_pkCamera)        return;    updateOrientation();    updateModelViewMatrix();    updateProjectionMatrix();    float16 kViewPrj = m_kModelViewMatrix * m_kProjectionMatrix;    float16 kInvViewPrj = inverse(kViewPrj);        findFrustumCorners(m_akFrustum, kInvViewPrj);    m_uiIntersectionCount = findPlanarIntersections(m_akIntersections, m_akFrustum);    if(m_uiIntersectionCount > 0)    {        m_kRange = findProjectedRange(m_uiIntersectionCount, m_akIntersections, kViewPrj);        findProjectedCorners(m_akCorners, m_kRange, kInvViewPrj);        updateRangeMatrix(m_kRange);        m_bIsVisible = true;    }    else    {        m_bIsVisible = false;    }}

void CamtransCamera::orientLook(const Vector4 &eye, const Vector4 &look, const Vector4 &up){    // @TODO: [CAMTRANS] Fill this in...    m_n = look;    m_n = m_n.getNormalized();    m_n *= (-1);    m_n.unhomgenize();    REAL uProjection = m_n.dot( up );    m_v.x = up.x - uProjection*m_n.x;    m_v.y = up.y - uProjection*m_n.y;    m_v.z = up.z - uProjection*m_n.z;   m_v =  m_v.getNormalized();    m_v.unhomgenize();    m_u = m_v;    m_u = m_v.cross(m_n);    m_u.unhomgenize();    m_eyePosition = eye;    m_lookAt = look;    m_up = up;    REAL lN = m_lookAt.getMagnitude();    m_lookAt /= lN;    m_lookAt.unhomgenize();    m_up = m_v;    m_up.unhomgenize();    updateModelViewMatrix();    updateProjectionMatrix();}

void Camera::perspective(float nFov, float nAspect, float nNear, float nFar) {	fov = nFov;	aspect = nAspect;	near = nNear;	far = nFar;	projection_type = PERSPECTIVE;	updateProjectionMatrix();}

int windowSizeUpdated(unsigned int newWidth , unsigned int newHeight){   fprintf(stderr,"Window size changed to %u x %u/n",newWidth,newHeight);   WIDTH=newWidth;   HEIGHT=newHeight;   updateProjectionMatrix();   return 1;}

 void Camera::orthoTopLeft(float nWidth, float nHeight, float nNear, float nFar) {   ortho_width = nWidth;   ortho_height = nHeight;   n = nNear;   f = nFar;   projection_type = ORTHO_TOP_LEFT;   updateProjectionMatrix(); }

glm::mat4 Camera::getCameraMatrix(){	if( projectionChanged ){		updateProjectionMatrix();	}	if( eyeChanged ){		updateCameraMatrix();	}	return camera;}

/* Render::setSize: set size */void Render::setSize(int w, int h){   if (m_width != w || m_height != h) {      if (w > 0)         m_width = w;      if (h > 0)         m_height = h;      updateProjectionMatrix();   }}

 void RenderingManager::processChangedSettings(const Settings::CategorySettingVector &changed) {     for (Settings::CategorySettingVector::const_iterator it = changed.begin(); it != changed.end(); ++it)     {         if (it->first == "General" && it->second == "field of view")         {             mFieldOfView = Settings::Manager::getFloat("field of view", "General");             updateProjectionMatrix();         }         else if (it->first == "Camera" && it->second == "viewing distance")         {             mViewDistance = Settings::Manager::getFloat("viewing distance", "Camera");             mStateUpdater->setFogEnd(mViewDistance);             updateProjectionMatrix();         }         else if (it->first == "General" && (it->second == "texture filtering" || it->second == "anisotropy"))             updateTextureFiltering();     } }

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();}

 OrthographicCamera::OrthographicCamera(float _left, float _right, float _top, float _bottom, float _near, float _far)   : Camera(),     left(_left),     right(_right),     top(_top),     bottom(_bottom),     near(_near),     far(_far) {   updateProjectionMatrix(); }

void Camera::setFrustum(const float& rightMin, const float& rightMax, const float& upMin, const float& upMax, const float& frontMin, const float& frontMax) {	m_rightMin = rightMin;	m_rightMax = rightMax;	m_upMin = upMin;	m_upMax = upMax;	m_frontMin = frontMin;	m_frontMax = frontMax;	updateProjectionMatrix();	updateViewProjectionMatrix();	updateFrustumPlanesAndPoints();}

void Camera::setResolution(glm::vec2 resolution){    resX = resolution.x;    resY = resolution.y;        updateProjectionMatrix();        m_aspectRatio = resX / resY;    m_rasterBounds = Bounds2i( glm::vec2 ( -resX / 2.0, -resY / 2.0 ), glm::vec2 ( resX / 2.0, resY / 2.0 ) );    m_area = sensorArea();}

void SpatialCamera::setFrustum(const float& l, const float& r, const float& b, const float& t, const float& n, const float& f) {	m_projectionParameters.l = l;	m_projectionParameters.r = r;	m_projectionParameters.b = b;	m_projectionParameters.t = t;	m_projectionParameters.n = n;	m_projectionParameters.f = f;	updateProjectionMatrix();	updateViewProjectionMatrix();	updateFrustumPlanesAndPoints();}

// Reset the camera back to its defaultsvoid Camera::reset(){    setPosition(glm::vec3(0.0, 0.0, 0.5));    lookAt(glm::vec3(0.0, 0.0, -1.0), glm::vec3(0.0, 1.0, 0.0));    fieldOfView_   = 45.0f;         // frustrum viewing aperture    aspectRatio_   = 4.0f / 3.0f;   // frustrum view angling    nearFieldClip_ = 0.005f;        // clip anything closer than this    farFieldClip_  = 65536.0f;         // clip anything farther than this    updateProjectionMatrix();}

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

	void setViewOffset (T fullWidth, T fullHeight, T x, T y, T width, T height){		this->fullWidth = fullWidth;		this->fullHeight = fullHeight;		this->x = x;		this->y = y;		this->width = width;		this->height = height;		updateProjectionMatrix();	}

void Camera::setPerspective(float fov, float aspect, float near_plane, float far_plane){	type = PERSPECTIVE;	this->fov = fov;	this->aspect = aspect;	this->near_plane = near_plane;	this->far_plane = far_plane;	//update projection	updateProjectionMatrix();}

// Reset the camera back to its defaultsvoid Camera::reset(){    auto startPos = glm::vec3(0, -1, 0);    setPosition(startPos);    lookAt(glm::vec3(0, 0, 0), glm::vec3(0, 0, 1));    translate(-startPos);    fieldOfView_   = 45.0f;         // frustrum viewing aperture    aspectRatio_   = 4.0f / 3.0f;   // frustrum view angling    nearFieldClip_ = 0.005f;        // clip anything closer than this    farFieldClip_  = 65536.0f;      // clip anything farther than this    updateProjectionMatrix();}

void SpatialCamera::setFrustum(const float& upFovRadian, const float& aspectRatio, const float& n, const float& f) {	m_upFovRadian = upFovRadian;	m_aspectRatio = aspectRatio;	m_projectionParameters.n = n;	m_projectionParameters.f = f;	m_projectionParameters.t = n * tanf(0.5f * upFovRadian);	m_projectionParameters.r = aspectRatio * m_projectionParameters.t;	m_projectionParameters.b = -m_projectionParameters.t;	m_projectionParameters.l = -m_projectionParameters.r;	updateProjectionMatrix();	updateViewProjectionMatrix();	updateFrustumPlanesAndPoints();}