public virtual void RotationYawPitchRoll(Angle yaw, Angle pitch, Angle roll)
{
// this._orientation *= MathEngine.EulerToQuaternion(yaw.Radians, pitch.Radians, roll.Radians);
// Vector3 v = MathEngine.QuaternionToEuler(this._orientation);
// if(!double.IsNaN(v.Y))
// this._latitude.Radians = v.Y;
// if(!double.IsNaN(v.X))
// this._longitude.Radians = v.X;
// if(Math.Abs(roll.Radians)>Single.Epsilon)
// this._heading.Radians = v.Z;
m_Orientation = Quaternion4d.EulerToQuaternion(yaw.Radians, pitch.Radians, roll.Radians) * m_Orientation;
Point3d p = Quaternion4d.QuaternionToEuler(m_Orientation);
if (!double.IsNaN(p.Y))
{
_latitude.Radians = p.Y;
}
if (!double.IsNaN(p.X))
{
_longitude.Radians = p.X;
}
if (Math.Abs(roll.Radians)
> double.Epsilon)
{
_heading.Radians = p.Z;
}
}
/// <summary>
/// Initializes a new instance of the <see cref= "T:WorldWind.Camera.CameraBase"/> class.
/// </summary>
/// <param name="radius">Planet's radius in meters</param>
public CameraBase(double radius)
{
this._worldRadius = radius;
this._distance = this._worldRadius * 3;
this._altitude = this._distance;
maximumAltitude = 5 * this._worldRadius;
this.m_Orientation = Quaternion4d.EulerToQuaternion(0, 0, 0);
}
/// <summary>
/// Initializes a new instance of the <see cref= "T:WorldWind.Camera.WorldCamera"/> class.
/// </summary>
/// <param name="targetPosition"></param>
/// <param name="radius"></param>
public WorldCamera(Vector3 targetPosition, double radius) : base(radius)
{
this._targetOrientation = m_Orientation;
this._targetDistance = this._distance;
this._targetAltitude = this._altitude;
this._targetTilt = this._tilt;
this._targetFov = this._fov;
}
private const int DoubleTapDelay = 3000; // Double tap max time (ms)
/// <summary>
/// Initializes a new instance of the <see cref= "T:WorldWind.Camera.CameraBase"/> class.
/// </summary>
/// <param name="radius">Planet's radius in meters</param>
public CameraBase(double radius)
{
this._worldRadius = radius;
this._distance = this._worldRadius * 3;
this._altitude = this._distance;
maximumAltitude = 5 * this._worldRadius;
this.m_Orientation = Quaternion4d.EulerToQuaternion(0, 0, 0);
}
public static Matrix4x4d Rotate(Vector3d rotation)
{
var x = new Quaternion4d(new Vector3d(1, 0, 0), rotation.x * MathUtility.Deg2Rad);
var y = new Quaternion4d(new Vector3d(0, 1, 0), rotation.y * MathUtility.Deg2Rad);
var z = new Quaternion4d(new Vector3d(0, 0, 1), rotation.z * MathUtility.Deg2Rad);
return((z * y * x).ToMatrix4x4d());
}
public virtual void Update(Device device)
{
viewPort = device.Viewport;
Point3d p = Quaternion4d.QuaternionToEuler(m_Orientation);
if (!double.IsNaN(p.Y))
{
this._latitude.Radians = p.Y;
}
if (!double.IsNaN(p.X))
{
this._longitude.Radians = p.X;
}
if (!double.IsNaN(p.Z))
{
this._heading.Radians = p.Z;
}
ComputeProjectionMatrix(viewPort);
ComputeViewMatrix();
device.Transform.Projection = m_ProjectionMatrix;
device.Transform.View = m_ViewMatrix;
device.Transform.World = m_WorldMatrix;
ViewFrustum.Update(
Matrix.Multiply(m_absoluteWorldMatrix,
Matrix.Multiply(m_absoluteViewMatrix, m_absoluteProjectionMatrix)));
// Old view range (used in quadtile logic)
double factor = (this._altitude) / this._worldRadius;
if (factor > 1)
{
viewRange = Angle.FromRadians(Math.PI);
}
else
{
viewRange = Angle.FromRadians(Math.Abs(Math.Asin((this._altitude) / this._worldRadius)) * 2);
}
// True view range
if (factor < 1)
{
trueViewRange = Angle.FromRadians(Math.Abs(Math.Asin((this._distance) / this._worldRadius)) * 2);
}
else
{
trueViewRange = Angle.FromRadians(Math.PI);
}
World.Settings.cameraAltitudeMeters = Altitude;
World.Settings.cameraLatitude = _latitude;
World.Settings.cameraLongitude = _longitude;
World.Settings.cameraHeading = _heading;
World.Settings.cameraTilt = _tilt;
}
/// <summary>
/// Initializes a new instance of the <see cref= "T:WorldWind.Camera.WorldCamera"/> class.
/// </summary>
/// <param name="targetPosition"></param>
/// <param name="radius"></param>
public WorldCamera(Vector3 targetPosition, double radius)
: base(radius)
{
this._targetOrientation = m_Orientation;
this._targetDistance = this._distance;
this._targetAltitude = this._altitude;
this._targetTilt = this._tilt;
this._targetFov = this._fov;
}
const int DoubleTapDelay = 3000; // Double tap max time (ms)
/// <summary>
/// Initializes a new instance of the <see cref= "T:WorldWind.Camera.CameraBase"/> class.
/// </summary>
/// <param name="targetPosition"></param>
/// <param name="radius">Planet's radius in meters</param>
public CameraBase(Vector3 targetPosition, double radius)
{
this._worldRadius = radius;
this._distance = 2 * _worldRadius;
this._altitude = this._distance;
maximumAltitude = 20 * _worldRadius;
// this._orientation = MathEngine.EulerToQuaternion(0,0,0);
this.m_Orientation = Quaternion4d.EulerToQuaternion(0, 0, 0);
}
/// <summary>
/// Pan the camera using delta values
/// </summary>
/// <param name="lat">Latitude offset</param>
/// <param name="lon">Longitude offset</param>
public override void Pan(Angle lat, Angle lon)
{
// by zzm
//CheckLatLon(ref lat, ref lon);
if (World.Settings.cameraHasMomentum)
{
_latitudeMomentum += lat / 100;
_longitudeMomentum += lon / 100;
}
if (Angle.IsNaN(lat))
{
lat = this._targetLatitude;
}
if (Angle.IsNaN(lon))
{
lon = this._targetLongitude;
}
lat += _targetLatitude;
lon += _targetLongitude;
//CheckLatLon(ref lat, ref lon); // by zzm
if (Math.Abs(lat.Radians)
> Math.PI / 2 - 1e-3)
{
lat.Radians = Math.Sign(lat.Radians) * (Math.PI / 2 - 1e-3);
}
this._targetOrientation = Quaternion4d.EulerToQuaternion(lon.Radians, lat.Radians, _targetHeading.Radians);
Point3d v = Quaternion4d.QuaternionToEuler(this._targetOrientation);
if (!double.IsNaN(v.Y))
{
_targetLatitude.Radians = v.Y;
_targetLongitude.Radians = v.X;
_targetHeading.Radians = v.Z;
if (!World.Settings.cameraSmooth)
{
_latitude = _targetLatitude;
_longitude = _targetLongitude;
_heading = _targetHeading;
m_Orientation = _targetOrientation;
}
}
}
public override void RotationYawPitchRoll(Angle yaw, Angle pitch, Angle roll)
{
_targetOrientation = Quaternion4d.EulerToQuaternion(yaw.Radians, pitch.Radians, roll.Radians) * _targetOrientation;
Point3d v = Quaternion4d.QuaternionToEuler(_targetOrientation);
if (!double.IsNaN(v.Y))
{
this._targetLatitude.Radians = v.Y;
}
if (!double.IsNaN(v.X))
{
this._targetLongitude.Radians = v.X;
}
if (Math.Abs(roll.Radians) > double.Epsilon)
{
this._targetHeading.Radians = v.Z;
}
}
public override void RotationYawPitchRoll(Angle yaw, Angle pitch, Angle roll)
{
if (World.Settings.cameraHasMomentum)
{
_latitudeMomentum += pitch / 100;
_longitudeMomentum += yaw / 100;
_headingMomentum += roll / 100;
}
this._targetOrientation = Quaternion4d.EulerToQuaternion(yaw.Radians, pitch.Radians, roll.Radians) * _targetOrientation;
Point3d v = Quaternion4d.QuaternionToEuler(_targetOrientation);
if (!double.IsNaN(v.Y))
{
this._targetLatitude.Radians = v.Y;
this._targetLongitude.Radians = v.X;
}
base.RotationYawPitchRoll(yaw, pitch, roll);
}
public override void SetPosition(double lat, double lon, double heading, double _altitude, double tilt, double bank)
{
if (double.IsNaN(lat))
{
lat = this._latitude.Degrees;
}
if (double.IsNaN(lon))
{
lon = this._longitude.Degrees;
}
if (double.IsNaN(heading))
{
heading = this._heading.Degrees;
}
if (double.IsNaN(bank))
{
bank = _targetBank.Degrees;
}
this._targetOrientation = Quaternion4d.EulerToQuaternion(
MathEngine.DegreesToRadians(lon),
MathEngine.DegreesToRadians(lat),
MathEngine.DegreesToRadians(heading));
Point3d v = Quaternion4d.QuaternionToEuler(this._targetOrientation);
this._targetLatitude.Radians = v.Y;
this._targetLongitude.Radians = v.X;
this._targetHeading.Radians = v.Z;
if (!double.IsNaN(tilt))
{
this.Tilt = Angle.FromDegrees(tilt);
}
if (!double.IsNaN(_altitude))
{
Altitude = _altitude;
}
this.Bank = Angle.FromDegrees(bank);
}
/// <summary>
/// Sets camera position.
/// </summary>
/// <param name="lat">Latitude in decimal degrees</param>
/// <param name="lon">Longitude in decimal degrees</param>
/// <param name="heading">Heading in decimal degrees</param>
/// <param name="_altitude">Altitude above ground level in meters</param>
/// <param name="tilt">Tilt in decimal degrees</param>
/// <param name="bank">Camera bank (roll) in decimal degrees</param>
public virtual void SetPosition(double lat, double lon, double heading, double _altitude, double tilt, double bank)
{
if (double.IsNaN(lat))
{
lat = this._latitude.Degrees;
}
if (double.IsNaN(lon))
{
lon = this._longitude.Degrees;
}
if (double.IsNaN(heading))
{
heading = this._heading.Degrees;
}
if (double.IsNaN(bank))
{
bank = this._bank.Degrees;
}
m_Orientation = Quaternion4d.EulerToQuaternion(
MathEngine.DegreesToRadians(lon),
MathEngine.DegreesToRadians(lat),
MathEngine.DegreesToRadians(heading));
Point3d p = Quaternion4d.QuaternionToEuler(m_Orientation);
_latitude.Radians = p.Y;
_longitude.Radians = p.X;
_heading.Radians = p.Z;
if (!double.IsNaN(tilt))
{
Tilt = Angle.FromDegrees(tilt);
}
if (!double.IsNaN(_altitude))
{
this.Altitude = _altitude;
}
this.Bank = Angle.FromDegrees(bank);
}
/// <summary>
/// Pan the camera using delta values
/// </summary>
/// <param name="lat">Latitude offset</param>
/// <param name="lon">Longitude offset</param>
public virtual void Pan(Angle lat, Angle lon)
{
// by zzm
//CheckLatLon(ref lat, ref lon);
if (Angle.IsNaN(lat))
{
lat = this._latitude;
}
if (Angle.IsNaN(lon))
{
lon = this._longitude;
}
lat += _latitude;
lon += _longitude;
// this._orientation = MathEngine.EulerToQuaternion(
// lon.Radians,
// lat.Radians,
// _heading.Radians);
m_Orientation = Quaternion4d.EulerToQuaternion(lon.Radians, lat.Radians, _heading.Radians);
Point3d p = Quaternion4d.QuaternionToEuler(m_Orientation);
// Vector3 v = MathEngine.QuaternionToEuler(this._orientation);
// if(!double.IsNaN(v.Y))
// {
// this._latitude.Radians = v.Y;
// this._longitude.Radians = v.X;
// }
if (!double.IsNaN(p.Y))
{
//CheckLatLon(ref p.Y, ref p.X); // by zzm;
_latitude.Radians = p.Y;
_longitude.Radians = p.X;
}
}
protected void SlerpToTargetOrientation(double percent)
{
double c = Quaternion4d.Dot(m_Orientation, _targetOrientation);
if (c > 1.0)
{
c = 1.0;
}
else if (c < -1.0)
{
c = -1.0;
}
angle = Angle.FromRadians(Math.Acos(c));
m_Orientation = Quaternion4d.Slerp(m_Orientation, _targetOrientation, percent);
_tilt += (_targetTilt - _tilt) * percent;
_bank += (_targetBank - _bank) * percent;
_distance += (_targetDistance - _distance) * percent;
ComputeAltitude(_distance, _tilt);
_fov += (_targetFov - _fov) * percent;
}
/// <summary>
/// Pan the camera using delta values
/// </summary>
/// <param name="lat">Latitude offset</param>
/// <param name="lon">Longitude offset</param>
public virtual void Pan(Angle lat, Angle lon)
{
if (Angle.IsNaN(lat))
{
lat = this._latitude; // should be zero (PM 2007-05)
}
if (Angle.IsNaN(lon))
{
lon = this._longitude;
}
lat += _latitude;
lon += _longitude;
// this._orientation = MathEngine.EulerToQuaternion(
// lon.Radians,
// lat.Radians,
// _heading.Radians);
m_Orientation = Quaternion4d.EulerToQuaternion(
lon.Radians, lat.Radians, _heading.Radians);
Point3d p = Quaternion4d.QuaternionToEuler(m_Orientation);
// Vector3 v = MathEngine.QuaternionToEuler(this._orientation);
// if(!double.IsNaN(v.Y))
// {
// this._latitude.Radians = v.Y;
// this._longitude.Radians = v.X;
// }
if (!double.IsNaN(p.Y))
{
_latitude.Radians = p.Y;
_longitude.Radians = p.X;
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="name">Object description</param>
/// <param name="position">Object position (XYZ world coordinates)</param>
/// <param name="orientation">Object rotation (Quaternion)</param>
protected RenderableObject(string name, Point3d position, Quaternion4d orientation)
{
this.name = name;
this.position = position;
this.orientation = orientation;
}
/// <summary>
/// Pan the camera using delta values
/// </summary>
/// <param name="lat">Latitude offset</param>
/// <param name="lon">Longitude offset</param>
public virtual void Pan(Angle lat, Angle lon)
{
// by zzm
//CheckLatLon(ref lat, ref lon);
if (Angle.IsNaN(lat)) {
lat = this._latitude;
}
if (Angle.IsNaN(lon)) {
lon = this._longitude;
}
lat += _latitude;
lon += _longitude;
// this._orientation = MathEngine.EulerToQuaternion(
// lon.Radians,
// lat.Radians,
// _heading.Radians);
m_Orientation = Quaternion4d.EulerToQuaternion(lon.Radians, lat.Radians, _heading.Radians);
Point3d p = Quaternion4d.QuaternionToEuler(m_Orientation);
// Vector3 v = MathEngine.QuaternionToEuler(this._orientation);
// if(!double.IsNaN(v.Y))
// {
// this._latitude.Radians = v.Y;
// this._longitude.Radians = v.X;
// }
if (!double.IsNaN(p.Y)) {
//CheckLatLon(ref p.Y, ref p.X); // by zzm;
_latitude.Radians = p.Y;
_longitude.Radians = p.X;
}
}
public virtual void RotationYawPitchRoll(Angle yaw, Angle pitch, Angle roll)
{
// this._orientation *= MathEngine.EulerToQuaternion(yaw.Radians, pitch.Radians, roll.Radians);
// Vector3 v = MathEngine.QuaternionToEuler(this._orientation);
// if(!double.IsNaN(v.Y))
// this._latitude.Radians = v.Y;
// if(!double.IsNaN(v.X))
// this._longitude.Radians = v.X;
// if(Math.Abs(roll.Radians)>Single.Epsilon)
// this._heading.Radians = v.Z;
m_Orientation = Quaternion4d.EulerToQuaternion(yaw.Radians, pitch.Radians, roll.Radians)*m_Orientation;
Point3d p = Quaternion4d.QuaternionToEuler(m_Orientation);
if (!double.IsNaN(p.Y)) {
_latitude.Radians = p.Y;
}
if (!double.IsNaN(p.X)) {
_longitude.Radians = p.X;
}
if (Math.Abs(roll.Radians)
> double.Epsilon) {
_heading.Radians = p.Z;
}
}
/// <summary>
/// Sets camera position.
/// </summary>
/// <param name="lat">Latitude in decimal degrees</param>
/// <param name="lon">Longitude in decimal degrees</param>
/// <param name="heading">Heading in decimal degrees</param>
/// <param name="altitude">Altitude above ground level in meters</param>
/// <param name="tilt">Tilt in decimal degrees</param>
/// <param name="bank">Camera bank (roll) in decimal degrees</param>
public virtual void SetPosition(double lat, double lon, double heading, double altitude, double tilt, double bank)
{
if (double.IsNaN(lat)) {
lat = this._latitude.Degrees;
}
if (double.IsNaN(lon)) {
lon = this._longitude.Degrees;
}
if (double.IsNaN(heading)) {
heading = this._heading.Degrees;
}
if (double.IsNaN(bank)) {
bank = this._bank.Degrees;
}
//CheckLatLon(ref lat, ref lon);
m_Orientation = Quaternion4d.EulerToQuaternion(MathEngine.DegreesToRadians(lon), MathEngine.DegreesToRadians(lat), MathEngine.DegreesToRadians(heading));
Point3d p = Quaternion4d.QuaternionToEuler(m_Orientation);
_latitude.Radians = p.Y;
_longitude.Radians = p.X;
_heading.Radians = p.Z;
if (!double.IsNaN(tilt)) {
Tilt = Angle.FromDegrees(tilt);
}
if (!double.IsNaN(altitude)) {
this.Altitude = altitude;
}
this.Bank = Angle.FromDegrees(bank);
}
public override void RotationYawPitchRoll(Angle yaw, Angle pitch, Angle roll)
{
_targetOrientation = Quaternion4d.EulerToQuaternion(yaw.Radians, pitch.Radians, roll.Radians)*_targetOrientation;
Point3d v = Quaternion4d.QuaternionToEuler(_targetOrientation);
if (!double.IsNaN(v.Y)) {
this._targetLatitude.Radians = v.Y;
}
if (!double.IsNaN(v.X)) {
this._targetLongitude.Radians = v.X;
}
if (Math.Abs(roll.Radians)
> double.Epsilon) {
this._targetHeading.Radians = v.Z;
}
}
public override void SetPosition(double lat, double lon, double heading, double altitude, double tilt, double bank)
{
if (double.IsNaN(lat)) {
lat = this._latitude.Degrees;
}
if (double.IsNaN(lon)) {
lon = this._longitude.Degrees;
}
if (double.IsNaN(heading)) {
heading = this._heading.Degrees;
}
if (double.IsNaN(bank)) {
bank = _targetBank.Degrees;
}
// by zzm
//CheckLatLon(ref lat, ref lon);
this._targetOrientation = Quaternion4d.EulerToQuaternion(MathEngine.DegreesToRadians(lon), MathEngine.DegreesToRadians(lat), MathEngine.DegreesToRadians(heading));
Point3d v = Quaternion4d.QuaternionToEuler(this._targetOrientation);
this._targetLatitude.Radians = v.Y;
this._targetLongitude.Radians = v.X;
this._targetHeading.Radians = v.Z;
if (!double.IsNaN(tilt)) {
this.Tilt = Angle.FromDegrees(tilt);
}
if (!double.IsNaN(altitude)) {
Altitude = altitude;
}
this.Bank = Angle.FromDegrees(bank);
}
