private static Matrix3D GetViewMatrix(ProjectionCamera camera) { if (camera == null) throw new ArgumentNullException("camera"); // This math is identical to what you find documented for // D3DXMatrixLookAtRH with the exception that WPF uses a // LookDirection vector rather than a LookAt point. Vector3D zAxis = -camera.LookDirection; zAxis.Normalize(); Vector3D xAxis = Vector3D.CrossProduct(camera.UpDirection, zAxis); xAxis.Normalize(); Vector3D yAxis = Vector3D.CrossProduct(zAxis, xAxis); Vector3D position = (Vector3D)camera.Position; double offsetX = -Vector3D.DotProduct(xAxis, position); double offsetY = -Vector3D.DotProduct(yAxis, position); double offsetZ = -Vector3D.DotProduct(zAxis, position); Matrix3D m = new Matrix3D( xAxis.X, yAxis.X, zAxis.X, 0, xAxis.Y, yAxis.Y, zAxis.Y, 0, xAxis.Z, yAxis.Z, zAxis.Z, 0, offsetX, offsetY, offsetZ, 1); return m; }
private static void PositionPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { ProjectionCamera target = ((ProjectionCamera)d); target.PropertyChanged(PositionProperty); }
private static Matrix3D GetViewMatrix(ProjectionCamera camera) { Debug.Assert(camera != null, "Caller needs to ensure camera is non-null."); // This math is identical to what you find documented for // D3DXMatrixLookAtRH with the exception that WPF uses a // LookDirection vector rather than a LookAt point. Vector3D zAxis = -camera.LookDirection; zAxis.Normalize(); Vector3D xAxis = Vector3D.CrossProduct(camera.UpDirection, zAxis); xAxis.Normalize(); Vector3D yAxis = Vector3D.CrossProduct(zAxis, xAxis); Vector3D position = (Vector3D)camera.Position; double offsetX = -Vector3D.DotProduct(xAxis, position); double offsetY = -Vector3D.DotProduct(yAxis, position); double offsetZ = -Vector3D.DotProduct(zAxis, position); return new Matrix3D( xAxis.X, yAxis.X, zAxis.X, 0, xAxis.Y, yAxis.Y, zAxis.Y, 0, xAxis.Z, yAxis.Z, zAxis.Z, 0, offsetX, offsetY, offsetZ, 1); }
private static void FarPlaneDistancePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { ProjectionCamera target = ((ProjectionCamera)d); target.PropertyChanged(FarPlaneDistanceProperty); }
public CameraController(Camera c, IListLayout l, PointLight p) { camera = (ProjectionCamera)c; layout = l; light = p; try { Transform3DGroup group = camera.Transform as Transform3DGroup; RotateTransform3D rot = group.Children[0] as RotateTransform3D; cameraRotX = rot.Rotation as AxisAngleRotation3D; rot = group.Children[1] as RotateTransform3D; cameraRotY = rot.Rotation as AxisAngleRotation3D; rot = group.Children[2] as RotateTransform3D; cameraRotZ = rot.Rotation as AxisAngleRotation3D; } catch (Exception ) { System.Diagnostics.Debug.WriteLine("camera transformations are wrong!!!"); } try { Transform3DGroup group = light.Transform as Transform3DGroup; RotateTransform3D rot = group.Children[0] as RotateTransform3D; lightRotX = rot.Rotation as AxisAngleRotation3D; rot = group.Children[1] as RotateTransform3D; lightRotY = rot.Rotation as AxisAngleRotation3D; rot = group.Children[2] as RotateTransform3D; lightRotZ = rot.Rotation as AxisAngleRotation3D; } catch (Exception ) { System.Diagnostics.Debug.WriteLine("light transformations are wrong!!!"); } }
/// <summary> /// Create a MatrixCamera from an existing ProjectionCamera /// </summary> /// <param name="camera">Camera</param> /// <param name="width">Viewport height</param> /// <param name="height">Viewport width</param> /// <returns>MatrixCamera</returns> public static MatrixCamera CreateMatrixCamera( ProjectionCamera camera, double width, double height ) { MatrixCamera matrixCamera = new MatrixCamera( CreateViewMatrix( camera ), CreateProjectionMatrix( camera, width, height, camera.NearPlaneDistance, camera.FarPlaneDistance ) ); matrixCamera.Transform = camera.Transform; return matrixCamera; }
/// <summary> /// Create a MatrixCamera from an existing ProjectionCamera /// </summary> /// <param name="camera">Camera</param> /// <param name="width">Viewport height</param> /// <param name="height">Viewport width</param> /// <param name="near">Near plane distance</param> /// <param name="far">Far plane distance</param> /// <returns>MatrixCamera</returns> public static MatrixCamera CreateMatrixCamera( ProjectionCamera camera, double width, double height, double near, double far ) { MatrixCamera matrixCamera = new MatrixCamera( CreateViewMatrix( camera ), CreateProjectionMatrix( camera, width, height, near, far ) ); matrixCamera.Transform = camera.Transform; return matrixCamera; }
/// <summary> /// Create a Projection matrix from an existing ProjectionCamera and view size /// (code acquired with Reflector) /// </summary> /// <param name="camera">Camera</param> /// <param name="width">Width</param> /// <param name="height">Height</param> public static Matrix3D CreateProjectionMatrix( ProjectionCamera camera, double width, double height, double near, double far ) { double aspectRatio = width / height; double zn = near; double zf = far; double fov = ( camera is PerspectiveCamera ) ? ( camera as PerspectiveCamera ).FieldOfView : 60; double num2 = Math.Tan( DegreesToRadians( fov ) / 2 ); double num5 = aspectRatio / num2; double num4 = 1 / num2; double num = ( zf != double.PositiveInfinity ) ? ( zf / ( zn - zf ) ) : -1; return new Matrix3D( num4, 0, 0, 0, 0, num5, 0, 0, 0, 0, num, -1, 0, 0, zn * num, 0 ); }
/// <summary> /// Animates the camera position and directions. /// </summary> /// <param name="camera"> /// The camera to animate. /// </param> /// <param name="newPosition"> /// The position to animate to. /// </param> /// <param name="newDirection"> /// The direction to animate to. /// </param> /// <param name="newUpDirection"> /// The up direction to animate to. /// </param> /// <param name="animationTime"> /// Animation time in milliseconds. /// </param> public static void AnimateTo( ProjectionCamera camera, Point3D newPosition, Vector3D newDirection, Vector3D newUpDirection, double animationTime) { var fromPosition = camera.Position; var fromDirection = camera.LookDirection; var fromUpDirection = camera.UpDirection; camera.Position = newPosition; camera.LookDirection = newDirection; camera.UpDirection = newUpDirection; if (animationTime > 0) { var a1 = new Point3DAnimation( fromPosition, newPosition, new Duration(TimeSpan.FromMilliseconds(animationTime))) { AccelerationRatio = 0.3, DecelerationRatio = 0.5, FillBehavior = FillBehavior.Stop }; a1.Completed += (s, a) => { camera.BeginAnimation(ProjectionCamera.PositionProperty, null); }; camera.BeginAnimation(ProjectionCamera.PositionProperty, a1); var a2 = new Vector3DAnimation( fromDirection, newDirection, new Duration(TimeSpan.FromMilliseconds(animationTime))) { AccelerationRatio = 0.3, DecelerationRatio = 0.5, FillBehavior = FillBehavior.Stop }; a2.Completed += (s, a) => { camera.BeginAnimation(ProjectionCamera.LookDirectionProperty, null); }; camera.BeginAnimation(ProjectionCamera.LookDirectionProperty, a2); var a3 = new Vector3DAnimation( fromUpDirection, newUpDirection, new Duration(TimeSpan.FromMilliseconds(animationTime))) { AccelerationRatio = 0.3, DecelerationRatio = 0.5, FillBehavior = FillBehavior.Stop }; a3.Completed += (s, a) => { camera.BeginAnimation(ProjectionCamera.UpDirectionProperty, null); }; camera.BeginAnimation(ProjectionCamera.UpDirectionProperty, a3); } }
/// <summary> /// Create a View matrix from an existing ProjectionCamera /// (code acquired with Reflector) /// </summary> /// <param name="camera">Camera</param> /// <returns>View matrix</returns> public static Matrix3D CreateViewMatrix( ProjectionCamera camera ) { Vector3D vectord2 = -camera.LookDirection; vectord2.Normalize(); Vector3D vectord3 = Vector3D.CrossProduct( camera.UpDirection, vectord2 ); vectord3.Normalize(); Vector3D vectord4 = Vector3D.CrossProduct( vectord2, vectord3 ); Vector3D vectord = (Vector3D)camera.Position; double offsetX = -Vector3D.DotProduct( vectord3, vectord ); double offsetY = -Vector3D.DotProduct( vectord4, vectord ); double offsetZ = -Vector3D.DotProduct( vectord2, vectord ); Matrix3D viewMatrix = new Matrix3D( vectord3.X, vectord4.X, vectord2.X, 0, vectord3.Y, vectord4.Y, vectord2.Y, 0, vectord3.Z, vectord4.Z, vectord2.Z, 0, offsetX, offsetY, offsetZ, 1 ); PrependInverseTransform( camera.Transform, ref viewMatrix ); return viewMatrix; }
public DepthPlanes( ProjectionCamera camera, BoundingBox bounds, double step ) { // Find closest visible point to camera Point3D position = camera.Transform.Transform( camera.Position ); Vector3D direction = camera.Transform.Transform( camera.LookDirection ); Point3D lookAt = position + ( direction * camera.NearPlaneDistance ); double xDir = Normalize( direction.X ); double yDir = Normalize( direction.Y ); double zDir = Normalize( direction.Z ); double biggest = Math.Max( Math.Max( Math.Abs( lookAt.X ), Math.Abs( lookAt.Y ) ), Math.Abs( lookAt.Z ) ); if ( xDir != 0 ) planes.Add( new Plane( new Vector3D( -xDir, 0, 0 ), -Distance( lookAt.X, biggest, bounds.Max.X, step ) ) ); if ( yDir != 0 ) planes.Add( new Plane( new Vector3D( 0, -yDir, 0 ), -Distance( lookAt.Y, biggest, bounds.Max.Y, step ) ) ); if ( zDir != 0 ) planes.Add( new Plane( new Vector3D( 0, 0, -zDir ), -Distance( lookAt.Z, biggest, bounds.Max.Z, step ) ) ); }
/// <summary> /// The update camera. /// </summary> /// <param name="camera"> /// The camera. /// </param> public void UpdateCamera(ProjectionCamera camera) { camera.Position = this.Position; camera.LookDirection = this.LookDirection; camera.UpDirection = this.UpDirection; camera.NearPlaneDistance = this.NearPlaneDistance; camera.FarPlaneDistance = this.FarPlaneDistance; var pcamera = camera as PerspectiveCamera; if (pcamera != null) { pcamera.FieldOfView = this.FieldOfView; } var ocamera = camera as OrthographicCamera; if (ocamera != null) { ocamera.Width = this.Width; } }
/// <summary> /// Initializes a new instance of the <see cref="CameraSetting"/> class. /// </summary> /// <param name="camera"> /// The camera. /// </param> public CameraSetting(ProjectionCamera camera) { this.Position = camera.Position; this.LookDirection = camera.LookDirection; this.UpDirection = camera.UpDirection; this.NearPlaneDistance = camera.NearPlaneDistance; this.FarPlaneDistance = camera.FarPlaneDistance; var pcamera = camera as PerspectiveCamera; if (pcamera != null) { this.FieldOfView = pcamera.FieldOfView; } var ocamera = camera as OrthographicCamera; if (ocamera != null) { this.Width = ocamera.Width; } }
/// <summary> /// Zooms to fit the specified bounding rectangle. /// </summary> /// <param name="actualCamera"> /// The actual camera. /// </param> /// <param name="viewport"> /// The viewport. /// </param> /// <param name="bounds"> /// The bounding rectangle. /// </param> /// <param name="animationTime"> /// The animation time. /// </param> public static void ZoomExtents( ProjectionCamera actualCamera, Viewport3D viewport, Rect3D bounds, double animationTime = 0) { var diagonal = new Vector3D(bounds.SizeX, bounds.SizeY, bounds.SizeZ); var center = bounds.Location + diagonal * 0.5; double radius = diagonal.Length * 0.5; ZoomExtents(actualCamera, viewport, center, radius, animationTime); }
/// <summary> /// Zooms to fit the extents of the specified viewport. /// </summary> /// <param name="actualCamera"> /// The actual camera. /// </param> /// <param name="viewport"> /// The viewport. /// </param> /// <param name="animationTime"> /// The animation time. /// </param> public static void ZoomExtents(ProjectionCamera actualCamera, Viewport3D viewport, double animationTime = 0) { var bounds = Visual3DHelper.FindBounds(viewport.Children); var diagonal = new Vector3D(bounds.SizeX, bounds.SizeY, bounds.SizeZ); if (bounds.IsEmpty || diagonal.LengthSquared == 0) { return; } ZoomExtents(actualCamera, viewport, bounds, animationTime); }
/// <summary> /// Set the camera target point and camera distance. /// </summary> /// <param name="camera"> /// The camera. /// </param> /// <param name="target"> /// The target point. /// </param> /// <param name="distance"> /// The distance to the camera. /// </param> /// <param name="animationTime"> /// The animation time. /// </param> public static void LookAt(ProjectionCamera camera, Point3D target, double distance, double animationTime) { Vector3D d = camera.LookDirection; d.Normalize(); LookAt(camera, target, d * distance, animationTime); }
public CameraAgent(ThreadViewport3D evtHost) { host = evtHost; cmr = (ProjectionCamera)host.Camera; }
/// <summary> /// Default constructor /// </summary> public Visualizer() { InitializeComponent(); HorizontalRotation = 1.86; VerticalRotation = 0.56; IsVisibleChanged += OnIsVisibleChanged; viewport.Camera = camera = new PerspectiveCamera(new Point3D(), new Vector3D(1, 0, 0), new Vector3D(0, 0, 1), FieldOfView); lightsContainer.Content = lightFromEyes; Transform3DGroup transform3DGroup = new Transform3DGroup(); transform3DGroup.Children.Add(new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(0, 1, 0), 20))); transform3DGroup.Children.Add(new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(1, 0, 0), -20))); lightsContainer.Transform = transform3DGroup; // Add ambient light viewport.Children.Add(new ModelVisual3D() { Content = lightAmbient }); #region Axis (for debug only) /*Cylinder xaxis = new Cylinder(new Point3D(), new Point3D(100, 0,0), 1); Cylinder yaxis = new Cylinder(new Point3D(), new Point3D(0, 100, 0), 1); Cylinder zaxis = new Cylinder(new Point3D(), new Point3D(0, 0, 100), 1); xaxis.Material = new DiffuseMaterial(new SolidColorBrush(Colors.Red)); yaxis.Material = new DiffuseMaterial(new SolidColorBrush(Colors.Green)); zaxis.Material = new DiffuseMaterial(new SolidColorBrush(Colors.Blue)); lightsContainer.Children.Add(xaxis); lightsContainer.Children.Add(yaxis); lightsContainer.Children.Add(zaxis);*/ #endregion viewport.Children.Add(moleculesContainer); viewport.Children.Add(lightsContainer); viewport.Children.Add(shadowContainer); }
/// <summary> /// Creates preview of this control (automatically setup the camera) /// </summary> public void CreatePreview(RenderTargetBitmap renderTargetBitmap) { bool wasDetached = !dataAttached; AttachData(); if (moleculesContainer.Children.Count == 0) { if (wasDetached) DetachData(); return; } ProjectionCamera backupCamera = camera; Double backupWidth = Width; Double backupHeight = Height; // Change size of the visualizer Width = renderTargetBitmap.PixelWidth; Height = renderTargetBitmap.PixelHeight; Measure(new Size(renderTargetBitmap.PixelWidth, renderTargetBitmap.PixelHeight)); Arrange(new Rect(0, 0, renderTargetBitmap.PixelWidth, renderTargetBitmap.PixelHeight)); // Change camera // Prepare bounding box Rect3D boundingBox = VisualTreeHelper.GetDescendantBounds(moleculesContainer); if (boundingBox.IsEmpty) { renderTargetBitmap.Render(this); boundingBox = VisualTreeHelper.GetDescendantBounds(moleculesContainer); if (boundingBox.IsEmpty) return; } OrthographicCamera orthographicCamera = new OrthographicCamera(); #region Accomodate camera to fit content if (boundingBox.SizeZ < boundingBox.SizeX && boundingBox.SizeZ < boundingBox.SizeY) { orthographicCamera.Position = new Point3D(boundingBox.Location.X + boundingBox.SizeX / 2.0, boundingBox.Location.Y + boundingBox.SizeY / 2.0, boundingBox.Location.Z); orthographicCamera.LookDirection = new Vector3D(0, 0, 1); orthographicCamera.UpDirection = new Vector3D(0, 1, 0); orthographicCamera.Width = Math.Max(boundingBox.SizeX, boundingBox.SizeY) * (Width / Height); } else if (boundingBox.SizeX < boundingBox.SizeZ && boundingBox.SizeX < boundingBox.SizeY) { orthographicCamera.Position = new Point3D(boundingBox.Location.X, boundingBox.Location.Y + boundingBox.SizeY / 2.0, boundingBox.Location.Z + boundingBox.SizeZ / 2.0); orthographicCamera.LookDirection = new Vector3D(1, 0, 0); orthographicCamera.UpDirection = new Vector3D(0, 1, 0); orthographicCamera.Width = Math.Max(boundingBox.SizeY, boundingBox.SizeZ); } else { orthographicCamera.Position = new Point3D(boundingBox.Location.X + boundingBox.SizeX / 2.0, boundingBox.Location.Y, boundingBox.Location.Z + boundingBox.SizeZ / 2.0); orthographicCamera.LookDirection = new Vector3D(0, 1, 0); orthographicCamera.UpDirection = new Vector3D(1, 0, 0); orthographicCamera.Width = Math.Max(boundingBox.SizeX, boundingBox.SizeZ); } #endregion orthographicCamera.NearPlaneDistance = 0; // Set the camera & correct lights viewport.Camera = orthographicCamera; lightFromEyes.Direction = orthographicCamera.LookDirection; RenderOptions.SetEdgeMode(this, EdgeMode.Unspecified); UpdateLayout(); renderTargetBitmap.Render(this); // Restore original values of the properties viewport.Camera = camera = backupCamera; Width = backupWidth; Height = backupHeight; if (wasDetached) DetachData(); }
/// <summary> /// Changes the direction of a camera. /// </summary> /// <param name="camera"> /// The camera. /// </param> /// <param name="newLookDir"> /// The new look dir. /// </param> /// <param name="newUpDirection"> /// The new up direction. /// </param> /// <param name="animationTime"> /// The animation time. /// </param> public static void ChangeDirection( ProjectionCamera camera, Vector3D newLookDir, Vector3D newUpDirection, double animationTime) { var target = camera.Position + camera.LookDirection; double length = camera.LookDirection.Length; newLookDir.Normalize(); LookAt(camera, target, newLookDir * length, newUpDirection, animationTime); }
/// <summary> /// Zooms to fit the specified sphere. /// </summary> /// <param name="camera"> /// The camera to change. /// </param> /// <param name="viewport"> /// The viewport. /// </param> /// <param name="center"> /// The center of the sphere. /// </param> /// <param name="radius"> /// The radius of the sphere. /// </param> /// <param name="animationTime"> /// The animation time. /// </param> public static void ZoomExtents( ProjectionCamera camera, Viewport3D viewport, Point3D center, double radius, double animationTime = 0) { var perspectiveCamera = camera as PerspectiveCamera; if (perspectiveCamera != null) { FitView(camera, viewport, center, radius, perspectiveCamera.LookDirection, perspectiveCamera.UpDirection, animationTime); return; } var orthoCamera = camera as OrthographicCamera; if (orthoCamera != null) { FitView(camera, viewport, center, radius, orthoCamera.LookDirection, orthoCamera.UpDirection, animationTime); } }
/// <summary> /// Fits the specified bounding sphere to the view. /// </summary> /// <param name="camera">The camera to change.</param> /// <param name="viewport">The viewport.</param> /// <param name="center">The center of the sphere.</param> /// <param name="radius">The radius of the sphere.</param> /// <param name="lookDirection">The look direction.</param> /// <param name="upDirection">The up direction.</param> /// <param name="animationTime">The animation time.</param> public static void FitView( ProjectionCamera camera, Viewport3D viewport, Point3D center, double radius, Vector3D lookDirection, Vector3D upDirection, double animationTime = 0) { var perspectiveCamera = camera as PerspectiveCamera; if (perspectiveCamera != null) { var pcam = perspectiveCamera; double disth = radius / Math.Tan(0.5 * pcam.FieldOfView * Math.PI / 180); double vfov = pcam.FieldOfView; if (viewport.ActualWidth > 0 && viewport.ActualHeight > 0) { vfov *= viewport.ActualHeight / viewport.ActualWidth; } double distv = radius / Math.Tan(0.5 * vfov * Math.PI / 180); double dist = Math.Max(disth, distv); var dir = lookDirection; dir.Normalize(); LookAt(perspectiveCamera, center, dir * dist, upDirection, animationTime); return; } var orthographicCamera = camera as OrthographicCamera; if (orthographicCamera != null) { LookAt(orthographicCamera, center, lookDirection, upDirection, animationTime); double newWidth = radius * 2; if (viewport.ActualWidth > viewport.ActualHeight) { newWidth = radius * 2 * viewport.ActualWidth / viewport.ActualHeight; } AnimateWidth(orthographicCamera, newWidth, animationTime); } }
/// <summary> /// Zooms to fit the specified sphere. /// </summary> /// <param name="camera"> /// The camera. /// </param> /// <param name="viewport"> /// The viewport. /// </param> /// <param name="center"> /// The center of the sphere. /// </param> /// <param name="radius"> /// The radius of the sphere. /// </param> /// <param name="animationTime"> /// The animation time. /// </param> public static void ZoomExtents( ProjectionCamera camera, Viewport3D viewport, Point3D center, double radius, double animationTime = 0) { // var target = Camera.Position + Camera.LookDirection; if (camera is PerspectiveCamera) { var pcam = camera as PerspectiveCamera; double disth = radius / Math.Tan(0.5 * pcam.FieldOfView * Math.PI / 180); double vfov = pcam.FieldOfView / viewport.ActualWidth * viewport.ActualHeight; double distv = radius / Math.Tan(0.5 * vfov * Math.PI / 180); double dist = Math.Max(disth, distv); var dir = camera.LookDirection; dir.Normalize(); LookAt(camera, center, dir * dist, animationTime); } if (camera is OrthographicCamera) { LookAt(camera, center, camera.LookDirection, animationTime); double newWidth = radius * 2; if (viewport.ActualWidth > viewport.ActualHeight) { newWidth = radius * 2 * viewport.ActualWidth / viewport.ActualHeight; } AnimateWidth(camera as OrthographicCamera, newWidth, animationTime); } }
/// <summary> /// Set the camera target point without changing the look direction. /// </summary> /// <param name="camera"> /// The camera. /// </param> /// <param name="target"> /// The target. /// </param> /// <param name="animationTime"> /// The animation time. /// </param> public static void LookAt(ProjectionCamera camera, Point3D target, double animationTime) { LookAt(camera, target, camera.LookDirection, animationTime); }
/// <summary> /// Zooms the camera to the specified rectangle. /// </summary> /// <param name="camera"> /// The camera. /// </param> /// <param name="viewport"> /// The viewport. /// </param> /// <param name="zoomRectangle"> /// The zoom rectangle. /// </param> public static void ZoomToRectangle(ProjectionCamera camera, Viewport3D viewport, Rect zoomRectangle) { var topLeftRay = Viewport3DHelper.Point2DtoRay3D(viewport, zoomRectangle.TopLeft); var topRightRay = Viewport3DHelper.Point2DtoRay3D(viewport, zoomRectangle.TopRight); var centerRay = Viewport3DHelper.Point2DtoRay3D( viewport, new Point( (zoomRectangle.Left + zoomRectangle.Right) * 0.5, (zoomRectangle.Top + zoomRectangle.Bottom) * 0.5)); if (topLeftRay == null || topRightRay == null || centerRay == null) { // could not invert camera matrix return; } var u = topLeftRay.Direction; var v = topRightRay.Direction; var w = centerRay.Direction; u.Normalize(); v.Normalize(); w.Normalize(); var perspectiveCamera = camera as PerspectiveCamera; if (perspectiveCamera != null) { var distance = camera.LookDirection.Length; // option 1: change distance var newDistance = distance * zoomRectangle.Width / viewport.ActualWidth; var newLookDirection = newDistance * w; var newPosition = perspectiveCamera.Position + (distance - newDistance) * w; var newTarget = newPosition + newLookDirection; LookAt(camera, newTarget, newLookDirection, 200); // option 2: change fov // double newFieldOfView = Math.Acos(Vector3D.DotProduct(u, v)); // var newTarget = camera.Position + distance * w; // pcamera.FieldOfView = newFieldOfView * 180 / Math.PI; // LookAt(camera, newTarget, distance * w, 0); } var orthographicCamera = camera as OrthographicCamera; if (orthographicCamera != null) { orthographicCamera.Width *= zoomRectangle.Width / viewport.ActualWidth; var oldTarget = camera.Position + camera.LookDirection; var distance = camera.LookDirection.Length; var newTarget = centerRay.PlaneIntersection(oldTarget, w); if (newTarget != null) { orthographicCamera.LookDirection = w * distance; orthographicCamera.Position = newTarget.Value - orthographicCamera.LookDirection; } } }
/// <summary> /// Set the camera target point and look direction /// </summary> /// <param name="camera"> /// The camera. /// </param> /// <param name="target"> /// The target. /// </param> /// <param name="newLookDirection"> /// The new look direction. /// </param> /// <param name="animationTime"> /// The animation time. /// </param> public static void LookAt( ProjectionCamera camera, Point3D target, Vector3D newLookDirection, double animationTime) { LookAt(camera, target, newLookDirection, camera.UpDirection, animationTime); }
/// <summary> /// Sets the camera. /// </summary> /// <param name="camera">The camera.</param> /// <param name="changeUpDirectionFromZtoY">switch Y and Z if set to <c>true</c>.</param> public void SetCamera(ProjectionCamera camera, bool changeUpDirectionFromZtoY = true) { this.CamUp = new Vector3D(0, 1, 0); this.CamTarget = camera.Position + camera.LookDirection; this.CamPos = camera.Position; if (changeUpDirectionFromZtoY) { this.CamTarget = this.SwitchYZ(this.CamTarget); this.CamPos = this.SwitchYZ(this.CamPos); } var pc = camera as PerspectiveCamera; if (pc != null) { this.FieldOfView = pc.FieldOfView; } this.CamMotionUp = this.CamUp; this.CamMotionTarget = this.CamTarget; this.CamMotionPos = this.CamPos; }
/// <summary> /// Set the camera target point and directions /// </summary> /// <param name="camera"> /// The camera. /// </param> /// <param name="target"> /// The target. /// </param> /// <param name="newLookDirection"> /// The new look direction. /// </param> /// <param name="newUpDirection"> /// The new up direction. /// </param> /// <param name="animationTime"> /// The animation time. /// </param> public static void LookAt( ProjectionCamera camera, Point3D target, Vector3D newLookDirection, Vector3D newUpDirection, double animationTime) { Point3D newPosition = target - newLookDirection; if (camera is PerspectiveCamera) { AnimateTo(camera as PerspectiveCamera, newPosition, newLookDirection, newUpDirection, animationTime); } if (camera is OrthographicCamera) { AnimateTo(camera as OrthographicCamera, newPosition, newLookDirection, newUpDirection, animationTime); } }
/// <summary> /// Copies the specified camera, converts field of view/width if neccessary. /// </summary> /// <param name="source"> /// The source camera. /// </param> /// <param name="dest"> /// The destination camera. /// </param> public static void Copy(ProjectionCamera source, ProjectionCamera dest) { if (source == null || dest == null) { return; } dest.LookDirection = source.LookDirection; dest.Position = source.Position; dest.UpDirection = source.UpDirection; dest.NearPlaneDistance = source.NearPlaneDistance; dest.FarPlaneDistance = source.FarPlaneDistance; var psrc = source as PerspectiveCamera; var osrc = source as OrthographicCamera; var pdest = dest as PerspectiveCamera; var odest = dest as OrthographicCamera; if (pdest != null) { double fov = 45; if (psrc != null) { fov = psrc.FieldOfView; } if (osrc != null) { double dist = source.LookDirection.Length; fov = Math.Atan(osrc.Width / 2 / dist) * 180 / Math.PI * 2; } pdest.FieldOfView = fov; } if (odest != null) { double width = 100; if (psrc != null) { double dist = source.LookDirection.Length; width = Math.Tan(psrc.FieldOfView / 180 * Math.PI / 2) * dist * 2; } if (osrc != null) { width = osrc.Width; } odest.Width = width; } }
/// <summary> /// Renders visualizer to bitmap /// </summary> public void RenderTo(RenderTargetBitmap renderTargetBitmap) { bool wasDetached = !dataAttached; AttachData(); if (moleculesContainer.Children.Count == 0) { if (wasDetached) DetachData(); return; } ProjectionCamera backupCamera = camera; Double backupWidth = Width; Double backupHeight = Height; // Change size of the visualizer Width = renderTargetBitmap.PixelWidth; Height = renderTargetBitmap.PixelHeight; Measure(new Size(renderTargetBitmap.PixelWidth, renderTargetBitmap.PixelHeight)); Arrange(new Rect(0, 0, renderTargetBitmap.PixelWidth, renderTargetBitmap.PixelHeight)); // Finish the animations CompleteAnimation(); RenderOptions.SetEdgeMode(this, EdgeMode.Unspecified); UpdateLayout(); renderTargetBitmap.Render(this); // Restore original values of the properties viewport.Camera = camera = backupCamera; Width = backupWidth; Height = backupHeight; if (wasDetached) DetachData(); }
/// <summary> /// Copy the direction of the source <see cref="Camera"/>. Used for the CoordinateSystem view. /// </summary> /// <param name="source"> /// The source camera. /// </param> /// <param name="dest"> /// The destination camera. /// </param> /// <param name="distance"> /// New length of the LookDirection vector. /// </param> public static void CopyDirectionOnly(ProjectionCamera source, ProjectionCamera dest, double distance) { if (source == null || dest == null) { return; } Vector3D dir = source.LookDirection; dir.Normalize(); dir *= distance; dest.LookDirection = dir; dest.Position = new Point3D(-dest.LookDirection.X, -dest.LookDirection.Y, -dest.LookDirection.Z); dest.UpDirection = source.UpDirection; }
public static void SetDirection(ProjectionCamera target, ProjectionCamera source) { target.LookDirection = source.LookDirection; target.UpDirection = source.UpDirection; }