StelMovementMgr.cpp   StelMovementMgr.cpp 
/* /*
* Stellarium * Stellarium
* Copyright (C) 2007 Fabien Chereau * Copyright (C) 2007 Fabien Chereau
* Copyright (C) 2015 Georg Zotti (offset view adaptations)
* *
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2 * as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version. * of the License, or (at your option) any later version.
* *
* This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
skipping to change at line 105 skipping to change at line 106
mouseZoomSpeed = conf->value("navigation/mouse_zoom",30).toInt(); mouseZoomSpeed = conf->value("navigation/mouse_zoom",30).toInt();
flagEnableZoomKeys = conf->value("navigation/flag_enable_zoom_keys") .toBool(); flagEnableZoomKeys = conf->value("navigation/flag_enable_zoom_keys") .toBool();
flagEnableMoveKeys = conf->value("navigation/flag_enable_move_keys") .toBool(); flagEnableMoveKeys = conf->value("navigation/flag_enable_move_keys") .toBool();
keyMoveSpeed = conf->value("navigation/move_speed",0.0004f).toFloat( ); keyMoveSpeed = conf->value("navigation/move_speed",0.0004f).toFloat( );
keyZoomSpeed = conf->value("navigation/zoom_speed", 0.0004f).toFloat (); keyZoomSpeed = conf->value("navigation/zoom_speed", 0.0004f).toFloat ();
autoMoveDuration = conf->value ("navigation/auto_move_duration",1.5f ).toFloat(); autoMoveDuration = conf->value ("navigation/auto_move_duration",1.5f ).toFloat();
flagManualZoom = conf->value("navigation/flag_manual_zoom").toBool() ; flagManualZoom = conf->value("navigation/flag_manual_zoom").toBool() ;
flagAutoZoomOutResetsDirection = conf->value("navigation/auto_zoom_o ut_resets_direction", true).toBool(); flagAutoZoomOutResetsDirection = conf->value("navigation/auto_zoom_o ut_resets_direction", true).toBool();
flagEnableMouseNavigation = conf->value("navigation/flag_enable_mous e_navigation",true).toBool(); flagEnableMouseNavigation = conf->value("navigation/flag_enable_mous e_navigation",true).toBool();
minFov = 0.001389; // minimal FOV = 5" minFov = conf->value("navigation/min_fov",0.001389).toDouble(); // d
// GZ: This value should be configurable! Zooming in too much is use efault: minimal FOV = 5"
less for archaeoastronomy.
minFov = conf->value("navigation/min_fov",minFov).toDouble();
maxFov = 100.; maxFov = 100.;
initFov = conf->value("navigation/init_fov",60.f).toFloat(); initFov = conf->value("navigation/init_fov",60.f).toFloat();
currentFov = initFov; currentFov = initFov;
setInitConstellationIntensity(conf->value("viewing/constellation_art _intensity", 0.5f).toFloat()); setInitConstellationIntensity(conf->value("viewing/constellation_art _intensity", 0.5f).toFloat());
Vec3f tmp = StelUtils::strToVec3f(conf->value("navigation/init_view_ pos").toString()); Vec3f tmp = StelUtils::strToVec3f(conf->value("navigation/init_view_ pos").toString());
initViewPos.set(tmp[0], tmp[1], tmp[2]); initViewPos.set(tmp[0], tmp[1], tmp[2]);
viewDirectionJ2000 = core->altAzToJ2000(initViewPos, StelCore::Refra ctionOff); viewDirectionJ2000 = core->altAzToJ2000(initViewPos, StelCore::Refra ctionOff);
QString tmpstr = conf->value("navigation/viewing_mode", "horizon").t oString(); QString tmpstr = conf->value("navigation/viewing_mode", "horizon").t oString();
skipping to change at line 323 skipping to change at line 322
const float zoomDuration = 0.2f * qAbs(numSteps); const float zoomDuration = 0.2f * qAbs(numSteps);
zoomTo(getAimFov() * zoomFactor, zoomDuration); zoomTo(getAimFov() * zoomFactor, zoomDuration);
event->accept(); event->accept();
} }
void StelMovementMgr::addTimeDragPoint(int x, int y) void StelMovementMgr::addTimeDragPoint(int x, int y)
{ {
DragHistoryEntry e; DragHistoryEntry e;
e.runTime=StelApp::getInstance().getTotalRunTime(); e.runTime=StelApp::getInstance().getTotalRunTime();
e.jd=core->getJDay(); e.jd=core->getJD();
e.x=x; e.x=x;
e.y=y; e.y=y;
timeDragHistory.append(e); timeDragHistory.append(e);
if (timeDragHistory.size()>3) if (timeDragHistory.size()>3)
timeDragHistory.removeFirst(); timeDragHistory.removeFirst();
} }
bool StelMovementMgr::handlePinch(qreal scale, bool started) bool StelMovementMgr::handlePinch(qreal scale, bool started)
{ {
#ifdef Q_OS_WIN #ifdef Q_OS_WIN
skipping to change at line 465 skipping to change at line 464
} }
void StelMovementMgr::setInitViewDirectionToCurrent() void StelMovementMgr::setInitViewDirectionToCurrent()
{ {
initViewPos = core->j2000ToAltAz(viewDirectionJ2000, StelCore::Refra ctionOff); initViewPos = core->j2000ToAltAz(viewDirectionJ2000, StelCore::Refra ctionOff);
QString dirStr = QString("%1,%2,%3").arg(initViewPos[0]).arg(initVie wPos[1]).arg(initViewPos[2]); QString dirStr = QString("%1,%2,%3").arg(initViewPos[0]).arg(initVie wPos[1]).arg(initViewPos[2]);
StelApp::getInstance().getSettings()->setValue("navigation/init_view _pos", dirStr); StelApp::getInstance().getSettings()->setValue("navigation/init_view _pos", dirStr);
} }
/************************************************************************* /*************************************************************************
The selected objects changed, follow it it we were already following anoth er one The selected objects changed, follow it if we were already following anoth er one
*************************************************************************/ *************************************************************************/
void StelMovementMgr::selectedObjectChange(StelModule::StelModuleSelectActi on) void StelMovementMgr::selectedObjectChange(StelModule::StelModuleSelectActi on)
{ {
// If an object was selected keep the earth following // If an object was selected keep the earth following
if (objectMgr->getWasSelected()) if (objectMgr->getWasSelected())
{ {
if (getFlagTracking()) if (getFlagTracking())
setFlagLockEquPos(true); setFlagLockEquPos(true);
setFlagTracking(false); setFlagTracking(false);
} }
skipping to change at line 560 skipping to change at line 559
depl *= 0.2; depl *= 0.2;
deplzoom *= 0.2; deplzoom *= 0.2;
} }
if (deltaAz<0) if (deltaAz<0)
{ {
deltaAz = -depl/30; deltaAz = -depl/30;
if (deltaAz<-0.2) if (deltaAz<-0.2)
deltaAz = -0.2; deltaAz = -0.2;
} }
else else if (deltaAz>0)
{ {
if (deltaAz>0) deltaAz = (depl/30);
{ if (deltaAz>0.2)
deltaAz = (depl/30); deltaAz = 0.2;
if (deltaAz>0.2)
deltaAz = 0.2;
}
} }
if (deltaAlt<0) if (deltaAlt<0)
{ {
deltaAlt = -depl/30; deltaAlt = -depl/30;
if (deltaAlt<-0.2) if (deltaAlt<-0.2)
deltaAlt = -0.2; deltaAlt = -0.2;
} }
else else if (deltaAlt>0)
{ {
if (deltaAlt>0) deltaAlt = depl/30;
{ if (deltaAlt>0.2)
deltaAlt = depl/30; deltaAlt = 0.2;
if (deltaAlt>0.2)
deltaAlt = 0.2;
}
} }
if (deltaFov<0) if (deltaFov<0)
{ {
deltaFov = -deplzoom*5; deltaFov = -deplzoom*5;
if (deltaFov<-0.15*currentFov) if (deltaFov<-0.15*currentFov)
deltaFov = -0.15*currentFov; deltaFov = -0.15*currentFov;
} }
else else if (deltaFov>0)
{ {
if (deltaFov>0) deltaFov = deplzoom*5;
{ if (deltaFov>20)
deltaFov = deplzoom*5; deltaFov = 20;
if (deltaFov>20)
deltaFov = 20;
}
} }
if (deltaFov != 0 ) if (deltaFov != 0 )
{ {
changeFov(deltaFov); changeFov(deltaFov);
} }
panView(deltaAz, deltaAlt); panView(deltaAz, deltaAlt);
updateAutoZoom(deltaTime); updateAutoZoom(deltaTime);
} }
void StelMovementMgr::updateVisionVector(double deltaTime) void StelMovementMgr::updateVisionVector(double deltaTime)
{ {
if (flagAutoMove) if (flagAutoMove)
{ {
if (!move.targetObject.isNull()) if (!move.targetObject.isNull())
{ {
// if zooming in, object may be moving so be sure to zoom to latest position // if zooming in, object may be moving so be sure to zoom to latest position
move.aim = core->altAzToJ2000(move.targetObject->get // In case we have offset center, we want object sti
AltAzPosAuto(core), StelCore::RefractionOff); ll visible in center.
// Note that if we do not center on an object, we se
t view direction of the potentially offset screen center!
// This is by design, to allow accurate setting of d
isplay coordinates.
Vec3d v;
switch (mountMode)
{
case MountAltAzimuthal:
v = move.targetObject->getAltAzPosAu
to(core);
break;
case MountEquinoxEquatorial:
v = move.targetObject->getEquinoxEqu
atorialPos(core);
break;
case MountGalactic:
v = move.targetObject->getGalacticPo
s(core);
break;
default:
qWarning() << "StelMovementMgr: unex
pected mountMode" << mountMode;
Q_ASSERT(0);
}
double lat, lon;
StelUtils::rectToSphe(&lon, &lat, v);
float altOffset=core->getCurrentStelProjectorParams(
).viewportCenterOffset[1]*currentFov*M_PI/180.0f;
lat+=altOffset;
StelUtils::spheToRect(lon, lat, v);
move.aim=mountFrameToJ2000(v);
move.aim.normalize(); move.aim.normalize();
move.aim*=2.; move.aim*=2.;
} }
move.coef+=move.speed*deltaTime*1000; move.coef+=move.speed*deltaTime*1000;
if (move.coef>=1.) if (move.coef>=1.)
{ {
flagAutoMove=false; flagAutoMove=false;
move.coef=1.; move.coef=1.;
} }
skipping to change at line 684 skipping to change at line 700
const double de_now = de_aim*c + de_start*(1.-c); const double de_now = de_aim*c + de_start*(1.-c);
const double ra_now = ra_aim*c + ra_start*(1.-c); const double ra_now = ra_aim*c + ra_start*(1.-c);
Vec3d tmp; Vec3d tmp;
StelUtils::spheToRect(ra_now, de_now, tmp); StelUtils::spheToRect(ra_now, de_now, tmp);
setViewDirectionJ2000(mountFrameToJ2000(tmp)); setViewDirectionJ2000(mountFrameToJ2000(tmp));
} }
else else
{ {
if (flagTracking && objectMgr->getWasSelected()) // Equatori al vision vector locked on selected object if (flagTracking && objectMgr->getWasSelected()) // Equatori al vision vector locked on selected object
{ {
Vec3d v = objectMgr->getSelectedObject()[0]->getAltA Vec3d v;
zPosAuto(core); switch (mountMode)
setViewDirectionJ2000(core->altAzToJ2000(v, StelCore {
::RefractionOff)); case MountAltAzimuthal:
v = objectMgr->getSelectedObject()[0
]->getAltAzPosAuto(core);
break;
case MountEquinoxEquatorial:
v = objectMgr->getSelectedObject()[0
]->getEquinoxEquatorialPos(core);
break;
case MountGalactic:
v = objectMgr->getSelectedObject()[0
]->getGalacticPos(core);
break;
default:
qWarning() << "StelMovementMgr: unex
pected mountMode" << mountMode;
Q_ASSERT(0);
}
double lat, lon; // general: longitudinal, latitudin
al
StelUtils::rectToSphe(&lon, &lat, v);
float latOffset=core->getCurrentStelProjectorParams(
).viewportCenterOffset[1]*currentFov*M_PI/180.0f;
lat+=latOffset;
StelUtils::spheToRect(lon, lat, v);
setViewDirectionJ2000(mountFrameToJ2000(v));
} }
else else
{ {
if (flagLockEquPos) // Equatorial vision vector lock ed if (flagLockEquPos) // Equatorial vision vector lock ed
{ {
// Recalc local vision vector // Recalc local vision vector
setViewDirectionJ2000(viewDirectionJ2000); setViewDirectionJ2000(viewDirectionJ2000);
} }
else else
{ {
// Vision vector locked to its position in t he mountFrame // Vision vector locked to its position in t he mountFrame
setViewDirectionJ2000(mountFrameToJ2000(view DirectionMountFrame)); setViewDirectionJ2000(mountFrameToJ2000(view DirectionMountFrame));
} }
} }
} }
} }
// Go and zoom to the selected object. // Go and zoom to the selected object. (Action linked to key, default "/")
void StelMovementMgr::autoZoomIn(float moveDuration, bool allowManualZoom) void StelMovementMgr::autoZoomIn(float moveDuration, bool allowManualZoom)
{ {
if (!objectMgr->getWasSelected()) if (!objectMgr->getWasSelected())
return; return;
moveDuration /= movementsSpeedFactor; moveDuration /= movementsSpeedFactor;
float manualMoveDuration; float manualMoveDuration;
if (!getFlagTracking()) if (!getFlagTracking())
{ {
setFlagTracking(true); setFlagTracking(true); // includes a call to moveToObject(), but without zooming=1!
moveToObject(objectMgr->getSelectedObject()[0], moveDuration , 1); moveToObject(objectMgr->getSelectedObject()[0], moveDuration , 1);
manualMoveDuration = moveDuration; manualMoveDuration = moveDuration;
} }
else else
{ {
// faster zoom in manual zoom mode once object is centered // faster zoom in manual zoom mode once object is centered
manualMoveDuration = moveDuration*.66f; manualMoveDuration = moveDuration*.66f;
} }
if( allowManualZoom && flagManualZoom ) if( allowManualZoom && flagManualZoom )
skipping to change at line 781 skipping to change at line 819
zoomTo(initFov, moveDuration); zoomTo(initFov, moveDuration);
if (flagAutoZoomOutResetsDirection) if (flagAutoZoomOutResetsDirection)
{ {
moveToJ2000(core->altAzToJ2000(getInitViewingDirection(), St elCore::RefractionOff), moveDuration, -1); moveToJ2000(core->altAzToJ2000(getInitViewingDirection(), St elCore::RefractionOff), moveDuration, -1);
setFlagTracking(false); setFlagTracking(false);
setFlagLockEquPos(false); setFlagLockEquPos(false);
} }
} }
// This is called when you press SPACEBAR: slowly centering&tracking object
void StelMovementMgr::setFlagTracking(bool b) void StelMovementMgr::setFlagTracking(bool b)
{ {
if (!b || !objectMgr->getWasSelected()) if (!b || !objectMgr->getWasSelected())
{ {
flagTracking=false; flagTracking=false;
} }
else else
{ {
moveToObject(objectMgr->getSelectedObject()[0], getAutoMoveD uration()); moveToObject(objectMgr->getSelectedObject()[0], getAutoMoveD uration());
flagTracking=true; flagTracking=true;
} }
} }
/////////////////////////////////////////////////////////////////////////// ///// /////////////////////////////////////////////////////////////////////////// /////
// Move to the given J2000 equatorial position // Move to the given J2000 equatorial position
void StelMovementMgr::moveToJ2000(const Vec3d& aim, float moveDuration, int zooming) void StelMovementMgr::moveToJ2000(const Vec3d& aim, float moveDuration, int zooming)
{ {
moveDuration /= movementsSpeedFactor; moveDuration /= movementsSpeedFactor;
zoomingMode = zooming; zoomingMode = zooming;
move.aim=aim; move.aim=aim;
move.aim.normalize(); move.aim.normalize();
move.aim*=2.; move.aim*=2.;
move.start=viewDirectionJ2000; move.start=viewDirectionJ2000;
move.start.normalize(); move.start.normalize();
skipping to change at line 863 skipping to change at line 903
return Vec3d(0); return Vec3d(0);
} }
void StelMovementMgr::setViewDirectionJ2000(const Vec3d& v) void StelMovementMgr::setViewDirectionJ2000(const Vec3d& v)
{ {
core->lookAtJ2000(v, getViewUpVectorJ2000()); core->lookAtJ2000(v, getViewUpVectorJ2000());
viewDirectionJ2000 = v; viewDirectionJ2000 = v;
viewDirectionMountFrame = j2000ToMountFrame(v); viewDirectionMountFrame = j2000ToMountFrame(v);
} }
void StelMovementMgr::panView(double deltaAz, double deltaAlt) void StelMovementMgr::panView(const double deltaAz, const double deltaAlt)
{ {
double azVision, altVision; double azVision, altVision;
StelUtils::rectToSphe(&azVision,&altVision,j2000ToMountFrame(viewDir ectionJ2000)); StelUtils::rectToSphe(&azVision,&altVision,j2000ToMountFrame(viewDir ectionJ2000));
// if we are moving in the Azimuthal angle (left/right) // if we are moving in the Azimuthal angle (left/right)
if (deltaAz) if (deltaAz)
azVision-=deltaAz; azVision-=deltaAz;
if (deltaAlt) if (deltaAlt)
{ {
if (altVision+deltaAlt <= M_PI_2 && altVision+deltaAlt >= -M _PI_2) altVision+=deltaAlt; if (altVision+deltaAlt <= M_PI_2 && altVision+deltaAlt >= -M _PI_2) altVision+=deltaAlt;
skipping to change at line 902 skipping to change at line 942
{ {
core->setTimeRate(0); core->setTimeRate(0);
Vec3d v1, v2; Vec3d v1, v2;
const StelProjectorP prj = core->getProjection(StelCore::Fra meEquinoxEqu); const StelProjectorP prj = core->getProjection(StelCore::Fra meEquinoxEqu);
prj->unProject(x2,y2, v2); prj->unProject(x2,y2, v2);
prj->unProject(x1,y1, v1); prj->unProject(x1,y1, v1);
v1[2]=0; v1.normalize(); v1[2]=0; v1.normalize();
v2[2]=0; v2.normalize(); v2[2]=0; v2.normalize();
double angle = (v2^v1)[2]; double angle = (v2^v1)[2];
double deltaDay = angle/(2.*M_PI)*core->getLocalSiderealDayL ength(); double deltaDay = angle/(2.*M_PI)*core->getLocalSiderealDayL ength();
core->setJDay(core->getJDay()+deltaDay); core->setJD(core->getJD()+deltaDay);
addTimeDragPoint(x2, y2); addTimeDragPoint(x2, y2);
} }
else else
{ {
Vec3d tempvec1, tempvec2; Vec3d tempvec1, tempvec2;
const StelProjectorP prj = core->getProjection(StelCore::Fra meJ2000); const StelProjectorP prj = core->getProjection(StelCore::Fra meJ2000);
prj->unProject(x2,y2, tempvec2); prj->unProject(x2,y2, tempvec2);
prj->unProject(x1,y1, tempvec1); prj->unProject(x1,y1, tempvec1);
double az1, alt1, az2, alt2; double az1, alt1, az2, alt2;
StelUtils::rectToSphe(&az1, &alt1, j2000ToMountFrame(tempvec 1)); StelUtils::rectToSphe(&az1, &alt1, j2000ToMountFrame(tempvec 1));
skipping to change at line 928 skipping to change at line 968
} }
// Update autoZoom if activated // Update autoZoom if activated
void StelMovementMgr::updateAutoZoom(double deltaTime) void StelMovementMgr::updateAutoZoom(double deltaTime)
{ {
if (flagAutoZoom) if (flagAutoZoom)
{ {
// Use a smooth function // Use a smooth function
double c; double c;
if( zoomMove.start > zoomMove.aim ) if( zoomMove.startFov > zoomMove.aimFov )
{ {
// slow down as approach final view // slow down as we approach final view
c = 1 - (1-zoomMove.coef)*(1-zoomMove.coef)*(1-zoomM ove.coef); c = 1 - (1-zoomMove.coef)*(1-zoomMove.coef)*(1-zoomM ove.coef);
} }
else else
{ {
// speed up as leave zoom target // speed up as we leave zoom target
c = (zoomMove.coef)*(zoomMove.coef)*(zoomMove.coef); c = (zoomMove.coef)*(zoomMove.coef)*(zoomMove.coef);
} }
setFov(zoomMove.start + (zoomMove.aim - zoomMove.start) * c) double newFov=zoomMove.startFov + (zoomMove.aimFov - zoomMov
; e.startFov) * c;
zoomMove.coef+=zoomMove.speed*deltaTime*1000; zoomMove.coef+=zoomMove.speed*deltaTime*1000;
if (zoomMove.coef>=1.) if (zoomMove.coef>=1.)
{ {
flagAutoZoom = 0; flagAutoZoom = 0;
setFov(zoomMove.aim); newFov=zoomMove.aimFov;
}
setFov(newFov); // updates currentFov->don't use newFov late
r!
// In case we have offset center, we want object still visib
le in center.
if (flagTracking && objectMgr->getWasSelected()) // vision v
ector locked on selected object
{
Vec3d v;
switch (mountMode)
{
case MountAltAzimuthal:
v = objectMgr->getSelectedObject()[0
]->getAltAzPosAuto(core);
break;
case MountEquinoxEquatorial:
v = objectMgr->getSelectedObject()[0
]->getEquinoxEquatorialPos(core);
break;
case MountGalactic:
v = objectMgr->getSelectedObject()[0
]->getGalacticPos(core);
break;
default:
qWarning() << "StelMovementMgr: unex
pected mountMode" << mountMode;
Q_ASSERT(0);
}
double lat, lon; // general: longitudinal, latitudin
al
StelUtils::rectToSphe(&lon, &lat, v);
float latOffset=core->getCurrentStelProjectorParams(
).viewportCenterOffset[1]*currentFov*M_PI/180.0f;
lat+=latOffset;
StelUtils::spheToRect(lon, lat, v);
if (flagAutoMove)
{
move.aim=mountFrameToJ2000(v);
move.aim.normalize();
move.aim*=2.;
}
else
{
setViewDirectionJ2000(mountFrameToJ2000(v));
}
} }
} }
} }
// Zoom to the given field of view // Zoom to the given field of view
void StelMovementMgr::zoomTo(double aim_fov, float moveDuration) void StelMovementMgr::zoomTo(double aim_fov, float moveDuration)
{ {
moveDuration /= movementsSpeedFactor; moveDuration /= movementsSpeedFactor;
zoomMove.aim=aim_fov; zoomMove.aimFov=aim_fov;
zoomMove.start=currentFov; zoomMove.startFov=currentFov;
zoomMove.speed=1.f/(moveDuration*1000); zoomMove.speed=1.f/(moveDuration*1000);
zoomMove.coef=0.; zoomMove.coef=0.;
flagAutoZoom = true; flagAutoZoom = true;
} }
void StelMovementMgr::changeFov(double deltaFov) void StelMovementMgr::changeFov(double deltaFov)
{ {
// if we are zooming in or out // if we are zooming in or out
if (deltaFov) if (deltaFov)
setFov(currentFov + deltaFov); setFov(currentFov + deltaFov);
skipping to change at line 984 skipping to change at line 1065
// Fade out constellation art when FOV less 2 degrees // Fade out constellation art when FOV less 2 degrees
if (currentFov<=2.) if (currentFov<=2.)
artInt *= currentFov>1.? (currentFov-1.) : 0. ; artInt *= currentFov>1.? (currentFov-1.) : 0. ;
cmgr->setArtIntensity(artInt); cmgr->setArtIntensity(artInt);
} }
} }
double StelMovementMgr::getAimFov(void) const double StelMovementMgr::getAimFov(void) const
{ {
return (flagAutoZoom ? zoomMove.aim : currentFov); return (flagAutoZoom ? zoomMove.aimFov : currentFov);
} }
void StelMovementMgr::setMaxFov(double max) void StelMovementMgr::setMaxFov(double max)
{ {
maxFov = max; maxFov = max;
if (currentFov > max) if (currentFov > max)
{ {
setFov(max); setFov(max);
} }
} }
 End of changes. 26 change blocks. 
46 lines changed or deleted 147 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/