internal void Move(GeneralCameraComponent camera, KeywordMovingComponent movment)
{
var down = movment.IsKeywordDown ? 1f : 0.5f;
var speedCorrection = 16f * down;
var rotateCorrection = 5f * down;
Vector3 move = Vector3.Zero;
switch (movment.Direction)
{
case KeywordMovingComponent.MovingDirection.MoveForward:
//move = MoveForward(down);
move = camera.LookDirection * speedCorrection;
break;
case KeywordMovingComponent.MovingDirection.MoveBackward:
move = -camera.LookDirection * speedCorrection;
break;
case KeywordMovingComponent.MovingDirection.TurnLeft:
var axis = camera.UpDirection;
camera.LookDirection = camera.LookDirection
.TransformedNormal(Matrix4x4.CreateFromAxisAngle(axis, rotateCorrection.ToRad()));
break;
case KeywordMovingComponent.MovingDirection.TurnRight:
camera.LookDirection = camera.LookDirection
.TransformedNormal(Matrix4x4.CreateFromAxisAngle(-camera.UpDirection, rotateCorrection.ToRad()));
break;
}
camera.Position += move;
}
/// <summary>
/// Initializes the 'turn-ball' rotation axes from the specified point.
/// </summary>
/// <param name="p1">
/// The point.
/// </param>
/// <param name="camera"></param>
/// <param name="rotationAxisX"></param>
/// <param name="rotationAxisY"></param>
/// <param name="viewportHeight"></param>
/// <param name="viewportWidth"></param>
public static void InitTurnballRotationAxes(Vector2 p1, int viewportWidth, int viewportHeight,
GeneralCameraComponent camera,
out Vector3 rotationAxisX, out Vector3 rotationAxisY)
{
double fx = p1.X / viewportWidth;
double fy = p1.Y / viewportHeight;
var up = Vector3.Normalize(camera.UpDirection);
var dir = Vector3.Normalize(camera.LookDirection);
var right = Vector3.Normalize(Vector3.Cross(dir, up));
rotationAxisX = up;
rotationAxisY = right;
if (fx > 0.8)
{
// delta.X = 0;
rotationAxisY = dir;
}
if (fx < 0.2)
{
// delta.X = 0;
rotationAxisY = -dir;
}
}
public static bool ChangeCameraDistance(GeneralCameraComponent camera, ref float delta, Vector3 zoomAround)
{
// Handle the 'zoomAround' point
var target = camera.Position + camera.LookDirection;
var relativeTarget = zoomAround - target;
var relativePosition = zoomAround - camera.Position;
if (relativePosition.Length() < 1e-4)
{
if (delta > 0) //If Zoom out from very close distance, increase the initial relativePosition
{
relativePosition.Normalize();
relativePosition /= 10;
}
else //If Zoom in too close, stop it.
{
return(false);
}
}
var f = Math.Pow(2.5, delta);
var newRelativePosition = relativePosition * (float)f;
var newRelativeTarget = relativeTarget * (float)f;
var newTarget = zoomAround - newRelativeTarget;
var newPosition = zoomAround - newRelativePosition;
var newDistance = (newPosition - zoomAround).Length();
var oldDistance = (camera.Position - zoomAround).Length();
if (newDistance > camera.FarPlaneDistance && (oldDistance < camera.FarPlaneDistance || newDistance > oldDistance))
{
var ratio = (newDistance - camera.FarPlaneDistance) / newDistance;
f *= 1 - ratio;
newRelativePosition = relativePosition * (float)f;
newRelativeTarget = relativeTarget * (float)f;
newTarget = zoomAround - newRelativeTarget;
newPosition = zoomAround - newRelativePosition;
delta = (float)(Math.Log(f) / Math.Log(2.5));
}
if (newDistance < camera.NearPlaneDistance && (oldDistance > camera.NearPlaneDistance || newDistance < oldDistance))
{
var ratio = (camera.NearPlaneDistance - newDistance) / newDistance;
f *= (1 + ratio);
newRelativePosition = relativePosition * (float)f;
newRelativeTarget = relativeTarget * (float)f;
newTarget = zoomAround - newRelativeTarget;
newPosition = zoomAround - newRelativePosition;
delta = (float)(Math.Log(f) / Math.Log(2.5));
}
var newLookDirection = newTarget - newPosition;
camera.LookDirection = newLookDirection.Normalized();
camera.Position = newPosition;
return(true);
}
protected override bool Executing(GraphicEntity entity, GeneralCameraComponent comp)
{
var mcomp = new Systems.CollidingWithScreenRayComponent();
mcomp.ScreenPosition = InputState.CurrentPosition;
entity.AddComponent(mcomp);
return(true);
}
protected override bool Executing(GeneralCameraComponent comp)
{
var p1 = InputState.PrevPosition;
var p2 = InputState.CurrentPosition;
var move = new Vector2(p2.X - p1.X, p2.Y - p1.Y);
// comp.Pan(move);
return(true);
}
public static Vector3 ScreenToV3(GeneralCameraComponent camera, Vector2 screen, float winW, float winH, float delta)
{
var c = new Viewport().UnProject(camera.GetState(), winW, winH, screen);
var plane = new SharpDX.Plane(camera.Position.ToSDXVector3(), camera.LookDirection.ToSDXVector3());
var ray = new SharpDX.Ray(c.Origin.ToSDXVector3(), -c.Direction.ToSDXVector3());
var inter = plane.Intersects(ref ray, out SharpDX.Vector3 point);
return(new Vector3(point.X, point.Y, point.Z));
}
/// <summary>
/// Rotates around three axes.
/// </summary>
/// <param name="cameraMode">The camera mode.</param>
/// <param name="p1">The p1.</param>
/// <param name="p2">The p2.</param>
/// <param name="rotateAround">The rotate around.</param>
/// <param name="sensitivity">The sensitivity.</param>
/// <param name="viewportWidth">Width of the viewport.</param>
/// <param name="viewportHeight">Height of the viewport.</param>
/// <param name="camera">The camera.</param>
/// <param name="invertFactor">The invert factor. Right Handed = 1; Left Handed = -1</param>
/// <param name="newPosition">The new position.</param>
/// <param name="newLookDirection">The new look direction.</param>
/// <param name="newUpDirection">The new up direction.</param>
public static void RotateTurnball(CameraMode cameraMode, ref Vector2 p1, ref Vector2 p2, ref Vector3 rotateAround,
float sensitivity,
int viewportWidth, int viewportHeight,
GeneralCameraComponent camera, int invertFactor,
out Vector3 newPosition, out Vector3 newLookDirection, out Vector3 newUpDirection)
{
InitTurnballRotationAxes(p1, viewportWidth, viewportHeight, camera, out var rotationAxisX, out var rotationAxisY);
Vector2 delta = p2 - p1;
var relativeTarget = rotateAround - camera.Target;
var relativePosition = rotateAround - camera.Position;
float d = -1;
if (cameraMode != CameraMode.Inspect)
{
d = 0.2f;
}
d *= sensitivity;
var q1 = Quaternion.CreateFromAxisAngle(rotationAxisX, d * invertFactor * delta.X / 180 * (float)Math.PI);
var q2 = Quaternion.CreateFromAxisAngle(rotationAxisY, d * delta.Y / 180 * (float)Math.PI);
Quaternion q = q1 * q2;
var m = Matrix4x4.CreateFromQuaternion(q);
Vector3 newLookDir = Vector3.TransformNormal(Vector3.Normalize(camera.LookDirection), m);
newUpDirection = Vector3.TransformNormal(Vector3.Normalize(camera.UpDirection), m);
Vector3 newRelativeTarget = Vector3.Transform(relativeTarget, m);
Vector3 newRelativePosition = Vector3.Transform(relativePosition, m);
var newRightVector = Vector3.Cross(newLookDir, newUpDirection);
var modUpDir = Vector3.Cross(newRightVector, newLookDir);
if ((newUpDirection - modUpDir).Length() > 1e-8)
{
newUpDirection = modUpDir;
}
var newTarget = rotateAround - newRelativeTarget;
newPosition = rotateAround - newRelativePosition;
newLookDirection = newTarget - newPosition;
if (cameraMode != CameraMode.Inspect)
{
newPosition = camera.Position;
}
}
/// <summary>
/// Rotates using turntable.
/// </summary>
/// <param name="cameraMode">The camera mode.</param>
/// <param name="delta">The delta.</param>
/// <param name="rotateAround">The rotate around.</param>
/// <param name="sensitivity">The sensitivity.</param>
/// <param name="viewportWidth">Width of the viewport.</param>
/// <param name="viewportHeight">Height of the viewport.</param>
/// <param name="camera">The camera.</param>
/// <param name="invertFactor">The invert factor. Right Handed = 1; Left Handed = -1;</param>
/// <param name="modelUpDirection">The model up direction.</param>
/// <param name="newPosition">The new position.</param>
/// <param name="newLookDirection">The new look direction.</param>
/// <param name="newUpDirection">The new up direction.</param>
public static void RotateTurntable(CameraMode cameraMode, ref Vector2 delta, ref Vector3 rotateAround,
float sensitivity,
int viewportWidth, int viewportHeight,
GeneralCameraComponent camera, int invertFactor,
Vector3 modelUpDirection,
out Vector3 newPosition, out Vector3 newLookDirection, out Vector3 newUpDirection)
{
var relativeTarget = rotateAround - camera.Target;
var relativePosition = rotateAround - camera.Position;
var cUp = Vector3.Normalize(camera.UpDirection);
var up = modelUpDirection;
var dir = Vector3.Normalize(camera.LookDirection);
var right = Vector3.Cross(dir, cUp);
float d = -0.5f;
if (cameraMode != CameraMode.Inspect)
{
d *= -0.2f;
}
d *= sensitivity;
// up = Vector3.UnitY;
//right = Vector3.UnitX;
System.Diagnostics.Trace.WriteLine($"UP:{up} Right: {right}, delta: {delta}");
var q1 = Quaternion.CreateFromAxisAngle(up, d * invertFactor * delta.X / 180 * (float)Math.PI);
var q2 = Quaternion.CreateFromAxisAngle(right, d * delta.Y / 180 * (float)Math.PI);
Quaternion q = q1 * q2;
var m = Matrix4x4.CreateFromQuaternion(q);
newUpDirection = Vector3.TransformNormal(cUp, m);
var newRelativeTarget = Vector3.Transform(relativeTarget, m);
var newRelativePosition = Vector3.Transform(relativePosition, m);
var newTarget = rotateAround - newRelativeTarget;
newPosition = rotateAround - newRelativePosition;
newLookDirection = (newTarget - newPosition);
if (cameraMode != CameraMode.Inspect)
{
newPosition = camera.Position;
}
}
/// <summary>
/// Rotates the trackball.
/// </summary>
/// <param name="cameraMode">The camera mode.</param>
/// <param name="p1">The p1.</param>
/// <param name="p2">The p2.</param>
/// <param name="rotateAround">The rotate around.</param>
/// <param name="sensitivity">The sensitivity.</param>
/// <param name="viewportWidth">Width of the viewport.</param>
/// <param name="viewportHeight">Height of the viewport.</param>
/// <param name="camera">The camera.</param>
/// <param name="invertFactor">The invert factor. Right Handed System = 1; LeftHandedSystem = -1;</param>
/// <param name="newPosition">The new position.</param>
/// <param name="newLookDirection">The new look direction.</param>
/// <param name="newUpDirection">The new up direction.</param>
public static void RotateTrackball(CameraMode cameraMode, ref Vector2 p1, ref Vector2 p2, ref Vector3 rotateAround,
float sensitivity,
int viewportWidth, int viewportHeight, GeneralCameraComponent camera, int invertFactor,
out Vector3 newPosition, out Vector3 newLookDirection, out Vector3 newUpDirection)
{
// http://viewport3d.com/trackball.htm
// http://www.codeplex.com/3DTools/Thread/View.aspx?ThreadId=22310
var v1 = ProjectToTrackball(p1, viewportWidth, viewportHeight);
var v2 = ProjectToTrackball(p2, viewportWidth, viewportHeight);
var cUP = Vector3.Normalize(camera.UpDirection);
// transform the trackball coordinates to view space
var viewZ = Vector3.Normalize(camera.LookDirection * invertFactor);
var viewX = Vector3.Cross(cUP, viewZ) * invertFactor;
var viewY = Vector3.Cross(viewX, viewZ);
var u1 = (viewZ * v1.Z) + (viewX * v1.X) + (viewY * v1.Y);
var u2 = (viewZ * v2.Z) + (viewX * v2.X) + (viewY * v2.Y);
// Could also use the Camera ViewMatrix
// var vm = Viewport3DHelper.GetViewMatrix(this.ActualCamera);
// vm.Invert();
// var ct = new MatrixTransform3D(vm);
// var u1 = ct.Transform(v1);
// var u2 = ct.Transform(v2);
// Find the rotation axis and angle
var axis = Vector3.Cross(u1, u2);
if (axis.LengthSquared() < 1e-8)
{
newPosition = camera.Position;
newLookDirection = camera.LookDirection;
newUpDirection = camera.UpDirection;
return;
}
var angle = u1.AngleRad(u2);
// Create the transform
var rotate = Matrix4x4.CreateFromAxisAngle(Vector3.Normalize(axis), -angle * sensitivity * 5);
// Find vectors relative to the rotate-around point
var relativeTarget = rotateAround - camera.Target;
var relativePosition = rotateAround - camera.Position;
// Rotate the relative vectors
var newRelativeTarget = Vector3.Transform(relativeTarget, rotate);
var newRelativePosition = Vector3.Transform(relativePosition, rotate);
newUpDirection = Vector3.TransformNormal(cUP, rotate);
// Find new camera position
var newTarget = rotateAround - newRelativeTarget;
newPosition = rotateAround - newRelativePosition;
newLookDirection = newTarget - newPosition;
if (cameraMode != CameraMode.Inspect)
{
newPosition = camera.Position;
}
}
protected override bool Executing(GeneralCameraComponent comp)
{
return(false);
}
protected virtual bool Executing(GraphicEntity entity, GeneralCameraComponent comp)
{
return(true);
}
protected virtual bool Executing(GeneralCameraComponent comp)
{
return(true);
}
public RotationHandler(GeneralCameraComponent camera)
{
this.camera = camera;
}
