protected override void UpdateModelFromMouse(Base3DElement selected3DElement, Vector mousePositionDelta)
{
Vector3D normal = this.CalculateTransformationForSpotLightAdorner().Transform(new Vector3D(0.0, 0.0, 1.0));
normal.Normalize();
Plane3D plane3D = new Plane3D(normal, this.centerOfCone);
Viewport3DVisual adorningViewport3D = this.ActiveView.AdornerLayer.GetAdornerSet3DContainer(this.ActiveAdorner.Element.Viewport).ShadowAdorningViewport3D;
Ray3D ray = CameraRayHelpers.RayFromViewportPoint(adorningViewport3D.Viewport.Size, adorningViewport3D.Camera, this.LastMousePosition + mousePositionDelta);
double t;
if (!plane3D.IntersectWithRay(ray, out t))
{
return;
}
double num1 = Math.Atan((ray.Evaluate(t) - this.centerOfCone).Length / 1.0) / Math.PI * 180.0;
SpotLight spotLight = (SpotLight)this.Selected3DElement.ViewObject.PlatformSpecificObject;
if (this.ActiveAdorner.TypeOfConeAngle == SpotLightAdornerBehavior3D.TypeOfConeAngle.InnerConeAngle)
{
double num2 = spotLight.OuterConeAngle - spotLight.InnerConeAngle;
this.Selected3DElement.SetValue(SpotLightElement.InnerConeAngleProperty, (object)num1);
this.Selected3DElement.SetValue(SpotLightElement.OuterConeAngleProperty, (object)(num1 + num2));
}
else
{
this.Selected3DElement.SetValue(SpotLightElement.OuterConeAngleProperty, (object)num1);
}
this.ActiveAdorner.PositionAndOrientGeometry();
}
public static Matrix3D GetTotalTransform(Viewport3DVisual vis)
{
Matrix3D matx = GetCameraTransform(vis);
matx.Append(GetViewportTransform(vis));
return(matx);
}
private void AutoZoom()
{
bool success;
Viewport3DVisual vp3dv = MeshDiagram3DMath.GetViewport3DVisual(mainViewport, out success);
if (TooBig(vp3dv, out success) && success)
{
while (TooBig(vp3dv, out success) && success)
{
Scale += 0.1;
}
while (!TooBig(vp3dv, out success) && Scale > 0 && success)
{
Scale -= 0.01;
}
Scale += 0.01;
}
else
{
while (!TooBig(vp3dv, out success) && success)
{
Scale -= 0.1;
if (Scale <= 0)
{
Scale = 0.01;
break;
}
}
while (TooBig(vp3dv, out success) && success)
{
Scale += 0.01;
}
}
}
/// <summary>
/// Gets the total transform (camera and viewport).
/// </summary>
/// <param name="viewport3DVisual">The viewport visual.</param>
/// <returns>The total transform.</returns>
public static Matrix3D GetTotalTransform(this Viewport3DVisual viewport3DVisual)
{
var m = GetCameraTransform(viewport3DVisual);
m.Append(GetViewportTransform(viewport3DVisual));
return(m);
}
/// <summary>
/// Viewport3D Constructor
/// </summary>
public Viewport3D()
{
_viewport3DVisual = new Viewport3DVisual();
// The value for the Camera property and the Children property on Viewport3D
// will also be the value for these properties on the Viewport3DVisual we
// create as an internal Visual child. This then will cause these values to
// be shared, which will break property inheritance, dynamic resource references
// and databinding. To prevent this, we mark the internal
// Viewport3DVisual.CanBeInheritanceContext to be false, allowing Camera and
// Children to only pick up value context from the Viewport3D (this).
_viewport3DVisual.CanBeInheritanceContext = false;
this.AddVisualChild(_viewport3DVisual);
// NTRAID#Longhorn-1219113-7/11/2005-Microsoft XamlSerializer does not support RO DPs
//
// The XamlSerializer currently only serializes locally set properties. To
// work around this we intentionally promote our ReadOnly Children
// property to locally set.
//
SetValue(ChildrenPropertyKey, _viewport3DVisual.Children);
_viewport3DVisual.SetInheritanceContextForChildren(this);
}
public static Matrix3D GetViewportTransform(Viewport3DVisual vis)
{
return(new Matrix3D(vis.Viewport.Width / 2, 0, 0, 0,
0, -vis.Viewport.Height / 2, 0, 0,
0, 0, 1, 0,
vis.Viewport.X + vis.Viewport.Width / 2,
vis.Viewport.Y + vis.Viewport.Height / 2, 0, 1));
}
/// <summary/>
protected override Viewport3DVisual CreateVisual()
{
Viewport3DVisual visual = new Viewport3DVisual();
visual.Camera = camera;
visual.Children.Add(modelVisual);
return(visual);
}
/// <summary>
/// Gets the object space to world space transformation for the given DependencyObject
/// </summary>
/// <param name="visual">The visual whose world space transform should be found</param>
/// <param name="viewport">The Viewport3DVisual the Visual is contained within</param>
/// <returns>The world space transformation</returns>
public static Matrix3D GetTransformToWorld(DependencyObject visual, out Viewport3DVisual viewport)
{
Matrix3D worldTransform = Matrix3D.Identity;
viewport = null;
if (visual == null)
{
return(worldTransform);
}
if (visual is Viewport3DVisual)
{
return(worldTransform);
}
if (!(visual is Visual3D))
{
throw new ArgumentException("Must be of type Visual3D or Viewport3DVisual.", "visual");
}
while (visual != null)
{
if (!(visual is ModelVisual3D))
{
break;
}
Transform3D transform = (Transform3D)visual.GetValue(ModelVisual3D.TransformProperty);
if (transform != null)
{
worldTransform.Append(transform.Value);
}
visual = VisualTreeHelper.GetParent(visual);
}
viewport = visual as Viewport3DVisual;
if (viewport == null)
{
if (visual != null)
{
// In WPF 3D v1 the only possible configuration is a chain of
// ModelVisual3Ds leading up to a Viewport3DVisual.
throw new ApplicationException(
String.Format("Unsupported type: '{0}'. Expected tree of ModelVisual3Ds leading up to a Viewport3DVisual.",
visual.GetType().FullName));
}
return(ZeroMatrix);
}
return(worldTransform);
}
/// <summary>
/// Converts the given point or ray hit test result into a PointHitTestResult.
/// In the case of a RayHitTestResult this is done by walking up the
/// transforming the 3D intersection into the coordinate space of the
/// Viewport3DVisual which contains the Visual3D subtree.
/// </summary>
internal static PointHitTestResult AsNearestPointHitTestResult(HitTestResult result)
{
if (result == null)
{
return(null);
}
PointHitTestResult resultAsPointHitTestResult = result as PointHitTestResult;
if (resultAsPointHitTestResult != null)
{
return(resultAsPointHitTestResult);
}
RayHitTestResult resultAsRayHitTestResult = result as RayHitTestResult;
if (resultAsRayHitTestResult != null)
{
Visual3D current = (Visual3D)resultAsRayHitTestResult.VisualHit;
Matrix3D worldTransform = Matrix3D.Identity;
while (true)
{
if (current.Transform != null)
{
worldTransform.Append(current.Transform.Value);
}
Visual3D parent3D = current.InternalVisualParent as Visual3D;
if (parent3D == null)
{
break;
}
current = parent3D;
}
Viewport3DVisual viewport = current.InternalVisualParent as Viewport3DVisual;
if (viewport != null)
{
Point4D worldPoint = ((Point4D)resultAsRayHitTestResult.PointHit) * worldTransform;
Point viewportPoint = viewport.WorldToViewport(worldPoint);
return(new PointHitTestResult(viewport, viewportPoint));
}
Debug.Fail("How did a ray hit a Visual3D not parented to a Viewport3DVisual?");
return(null);
}
Debug.Fail(String.Format("Unhandled HitTestResult type '{0}'", result.GetType().Name));
return(null);
}
public static Matrix3D GetViewportTransform(this Viewport3DVisual viewport3DVisual)
{
return(new Matrix3D(
viewport3DVisual.Viewport.Width / 2, 0, 0, 0,
0, -viewport3DVisual.Viewport.Height / 2, 0, 0,
0, 0, 1, 0,
viewport3DVisual.Viewport.X + (viewport3DVisual.Viewport.Width / 2), viewport3DVisual.Viewport.Y + (viewport3DVisual.Viewport.Height / 2), 0, 1
));
}
public static Point Point3DToScreen2D(Point3D point3D, Viewport3D viewPort)
{
Viewport3DVisual vpv = VisualTreeHelper.GetParent(viewPort.Children[0]) as Viewport3DVisual;
Matrix3D matrix3D = TryWorldToViewportTransform(vpv, out bool isOk);
Point3D pb = matrix3D.Transform(point3D);
return(new Point(pb.X, pb.Y));
}
/// <summary>
/// Computes the transform from the inner space of the given
/// Visual3D to the 2D space of the Viewport3DVisual which
/// contains it.
///
/// The result will contain the transform of the given visual.
///
/// This method can fail if Camera.Transform is non-invertable
/// in which case the camera clip planes will be coincident and
/// nothing will render. In this case success will be false.
/// </summary>
/// <param name="visual"></param>
/// <param name="success"></param>
/// <returns></returns>
public static Matrix3D TryTransformTo2DAncestor(DependencyObject visual, out Viewport3DVisual viewport, out bool success)
{
success = false;
Matrix3D to2D = Matrix3D.Identity;
viewport = null;
if (!(visual is Visual3D))
{
throw new ArgumentException("Must be of type Visual3D.", "visual");
}
while (visual != null)
{
if (!(visual is ModelVisual3D))
{
break;
}
Transform3D transform = (Transform3D)visual.GetValue(ModelVisual3D.TransformProperty);
if (transform != null)
{
to2D.Append(transform.Value);
}
visual = VisualTreeHelper.GetParent(visual);
}
viewport = visual as Viewport3DVisual;
if (viewport == null)
{
if (visual != null)
{
// In WPF 3D v1 the only possible configuration is a chain of
// ModelVisual3Ds leading up to a Viewport3DVisual.
throw new ApplicationException(
String.Format("Unsupported type: '{0}'. Expected tree of ModelVisual3Ds leading up to a Viewport3DVisual.",
visual.GetType().FullName));
}
return(ZeroMatrix);
}
success = true;
to2D.Append(MathUtils.TryWorldToViewportTransform(viewport, out success));
if (!success)
{
return(ZeroMatrix);
}
return(to2D);
}
// Convert a single point from 3D to 2D.
public static Point Convert3DPoint(Point3D point3d, Viewport3D vp)
{
// Get the combined transformation matrix.
Viewport3DVisual visual = VisualTreeHelper.GetParent(vp.Children[0]) as Viewport3DVisual;
Matrix3D matrix = GetWorldToViewportMatrix(visual);
// Transform the point.
point3d = matrix.Transform(point3d);
return(new Point(point3d.X, point3d.Y));
}
/// <summary/>
public SceneRenderer(Size windowSize, Viewport3DVisual visual, Color background, DepthTestFunction depthTest)
{
bool clipToBounds = visual.Clip != null && MathEx.ContainsCloseEnough(visual.Viewport, visual.Clip.Bounds);
InitializeThis(
visual.Camera,
ExtractModels(visual.Children),
new Bounds(windowSize, visual.Viewport, clipToBounds),
background,
depthTest);
}
/// <summary/>
protected override Viewport3DVisual CreateVisual()
{
Viewport3DVisual visual = new Viewport3DVisual();
visual.Camera = camera;
foreach (Visual3D visual3D in visual3Ds)
{
visual.Children.Add(visual3D);
}
return(visual);
}
public static IList <FindResult <T> > FindAll <T>(Viewport3DVisual viewport)
where T : DependencyObject
{
List <FindResult <T> > result = new List <FindResult <T> >();
foreach (Visual3D item in viewport.Children)
{
Find <T>(item, result);
}
return(result);
}
/// <summary>
/// Gets the 2D bounding box.
/// </summary>
/// <param name="modelVisual3D">The model visual 3D.</param>
/// <param name="success">if set to <c>true</c> [success].</param>
/// <returns></returns>
public static Rect Get2DBoundingBox(ModelVisual3D modelVisual3D, out bool success)
{
if (modelVisual3D != null)
{
Viewport3DVisual vp3dv = GetViewport3DVisual(modelVisual3D, out success);
if (success)
{
return(Get2DBoundingBox(modelVisual3D, vp3dv, out success));
}
}
success = false;
return(new Rect());
}
/// <summary>
/// Computes the transform from the inner space of the given
/// Visual3D to the 2D space of the Viewport3DVisual which
/// contains it.
///
/// The result will contain the transform of the given visual.
///
/// This method can fail if Camera.Transform is non-invertable
/// in which case the camera clip planes will be coincident and
/// nothing will render. In this case success will be false.
/// </summary>
/// <param name="visual"></param>
/// <param name="success"></param>
/// <returns></returns>
public static Matrix3D TryTransformTo2DAncestor(DependencyObject visual, out Viewport3DVisual viewport, out bool success)
{
Matrix3D to2D = GetWorldTransformationMatrix(visual, out viewport);
to2D.Append(MUtils.TryWorldToViewportTransform(viewport, out success));
if (!success)
{
return(ZeroMatrix);
}
return(to2D);
}
/// <summary>
/// Computes the transform from world space to the Viewport3DVisual's
/// inner 2D space.
///
/// This method can fail if Camera.Transform is non-invertable
/// in which case the camera clip planes will be coincident and
/// nothing will render. In this case success will be false.
/// </summary>
public static Matrix3D TryWorldToViewportTransform(Viewport3DVisual visual, out bool success)
{
Matrix3D result = TryWorldToCameraTransform(visual, out success);
if (success)
{
result.Append(GetProjectionMatrix(visual.Camera, Math2D.GetAspectRatio(visual.Viewport.Size)));
result.Append(GetHomogeneousToViewportTransform(visual.Viewport));
success = true;
}
return(result);
}
/// <summary>
/// Computes the transform from the inner space of the given
/// Visual3D to the camera coordinate space
///
/// The result will contain the transform of the given visual.
///
/// This method can fail if Camera.Transform is non-invertable
/// in which case the camera clip planes will be coincident and
/// nothing will render. In this case success will be false.
/// </summary>
/// <param name="visual"></param>
/// <param name="success"></param>
/// <returns></returns>
public static Matrix3D TryTransformToCameraSpace(DependencyObject visual, out Viewport3DVisual viewport, out bool success)
{
Matrix3D toViewSpace = GetWorldTransformationMatrix(visual, out viewport);
toViewSpace.Append(MUtils.TryWorldToCameraTransform(viewport, out success));
if (!success)
{
return(ZeroMatrix);
}
return(toViewSpace);
}
public static Rect Get2DBoundingBox(Viewport3D vp)
{
bool bOK;
Viewport3DVisual vpv =
VisualTreeHelper.GetParent(vp.Children[0]) as Viewport3DVisual;
Matrix3D m =
MathUtils.TryWorldToViewportTransform(vpv, out bOK);
bool bFirst = true;
Rect r = new Rect();
foreach (Visual3D v3d in vp.Children)
{
if (v3d is ModelVisual3D)
{
ModelVisual3D mv3d = (ModelVisual3D)v3d;
if (mv3d.Content is GeometryModel3D)
{
GeometryModel3D gm3d =
(GeometryModel3D)mv3d.Content;
if (gm3d.Geometry is MeshGeometry3D)
{
MeshGeometry3D mg3d =
(MeshGeometry3D)gm3d.Geometry;
foreach (Point3D p3d in mg3d.Positions)
{
Point3D pb = m.Transform(p3d);
Point p2d = new Point(pb.X, pb.Y);
if (bFirst)
{
r = new Rect(p2d, new Size(1, 1));
bFirst = false;
}
else
{
r.Union(p2d);
}
}
}
}
}
}
return(r);
}
/// <summary>
/// Computes the transformation matrix to go from a 3D point in the given Visual3D's coordinate space out in to
/// the Viewport3DVisual.
/// </summary>
internal static bool TryTransformToViewport3DVisual(Visual3D visual3D, out Viewport3DVisual viewport, out Matrix3D matrix)
{
matrix = GetWorldTransformationMatrix(visual3D, out viewport);
if (viewport != null)
{
matrix *= GetWorldToViewportTransform3D(viewport.Camera, viewport.Viewport);
return(true);
}
else
{
return(false);
}
}
public static Matrix3D GetWorldToViewportTransform(Viewport3DVisual visual)
{
bool success;
Matrix3D result = TryWorldToViewportTransform(visual, out success);
if (success)
{
return(result);
}
else
{
return(ZeroMatrix);
}
}
public static Matrix3D GetViewportToWorldTransform(Viewport3DVisual viewport)
{
Matrix3D matrix = GetWorldToViewportTransform(viewport);
if (matrix.HasInverse)
{
matrix.Invert();
return(matrix);
}
else
{
return(ZeroMatrix);
}
}
//private static Matrix3D GetTransformationMatrixFromViewPort2D( Viewport3DVisual viewPort3DVisual )
//{
// bool transoformationMatrixCalculationFinishesOK;
// Matrix3D transoformationMatrix =
// MathUtils.TryWorldToViewportTransform(viewPort3DVisual,
// out transoformationMatrixCalculationFinishesOK);
// if (!transoformationMatrixCalculationFinishesOK)
// throw new Exception("Transormation matrix cannot be calculated");
// return transoformationMatrix;
//}
public static Point Get2DPoint(Point3D point3d, Viewport3DVisual viewport3Dvisual)
{
bool TransformationResultOK;
Matrix3D m = MathUtils.TryWorldToViewportTransform(viewport3Dvisual, out TransformationResultOK);
if (!TransformationResultOK)
{
return(new Point(0, 0));
}
Point3D pb = m.Transform(point3d);
Point p2d = new Point(pb.X, pb.Y);
return(p2d);
}
public static FindResult <T> Find <T>(Viewport3DVisual viewport)
where T : DependencyObject
{
foreach (Visual3D item in viewport.Children)
{
FindResult <T> result = Find <T>(item);
if (result != null)
{
return(result);
}
}
return(null);
}
private bool TryUpadateTagLocations()
{
try
{
if (panorama.Viewport3D == null || panorama.Camera == null)
{
return(false);
}
if (!_panoramaStatusChanged)
{
return(false);
}
_panoramaStatusChanged = false;
Vector3D cameraLookDirection;
Matrix3D matrix3D;
Dispatcher.Invoke(() =>
{
cameraLookDirection = panorama.Camera.LookDirection;
Viewport3DVisual vpv = VisualTreeHelper.GetParent(panorama.Viewport3D.Children[0]) as Viewport3DVisual;
matrix3D = D3Helper.TryWorldToViewportTransform(vpv, out bool isOk);
});
Point3D point;
Point3D point3D = new Point3D(1, 0, 0);
if (Vector3D.DotProduct(cameraLookDirection, new Vector3D(point3D.X, point3D.Y, point3D.Z)) <= 0)
{
point = new Point3D(-10000, -10000, -10000);
}
else
{
//可能的耗时操作
point = matrix3D.Transform(new Point3D(1, 0, 0));
}
Dispatcher.Invoke(() =>
{
Canvas.SetLeft(tag, point.X);
Canvas.SetTop(tag, point.Y);
});
return(true);
}
catch
{
return(false);
}
}
/// <summary>
/// Computes the transform from world space to camera space
///
/// This method can fail if Camera.Transform is non-invertable
/// in which case the camera clip planes will be coincident and
/// nothing will render. In this case success will be false.
/// </summary>
public static Matrix3D TryWorldToCameraTransform(Viewport3DVisual visual, out bool success)
{
success = false;
if (visual == null)
{
return(ZeroMatrix);
}
Matrix3D result = Matrix3D.Identity;
Camera camera = visual.Camera;
if (camera == null)
{
return(ZeroMatrix);
}
Rect viewport = visual.Viewport;
if (viewport == Rect.Empty)
{
return(ZeroMatrix);
}
Transform3D cameraTransform = camera.Transform;
if (cameraTransform != null)
{
Matrix3D m = cameraTransform.Value;
if (!m.HasInverse)
{
return(ZeroMatrix);
}
m.Invert();
result.Append(m);
}
result.Append(GetViewMatrix(camera));
success = true;
return(result);
}
private HitTestFilterBehavior FilterPotentialHit(DependencyObject testObject)
{
Viewport3DVisual viewportVisual = testObject as Viewport3DVisual;
if (viewportVisual == null)
{
return(HitTestFilterBehavior.ContinueSkipSelf);
}
RectangleHitTestResult closestHitTestResult = new Viewport3DHitTestHelper(viewportVisual, (GeneralTransform)Transform.Identity).HitTest((HitTestParameters)this.hitTestParameters3D).ClosestHitTestResult;
if (closestHitTestResult == null)
{
return(HitTestFilterBehavior.ContinueSkipSelfAndChildren);
}
this.hitObject = closestHitTestResult;
return(HitTestFilterBehavior.Stop);
}
/// <summary>
/// Computes the transform from world space to the Viewport3DVisual's
/// inner 2D space.
///
/// This method can fail if Camera.Transform is non-invertable
/// in which case the camera clip planes will be coincident and
/// nothing will render. In this case success will be false.
/// </summary>
public static Matrix3D TryWorldToViewportTransform(Viewport3DVisual visual, out bool success)
{
success = false;
if (visual.Viewport.Width == 0 || visual.Viewport.Height == 0)
{
return(ZeroMatrix);
}
Matrix3D result = TryWorldToCameraTransform(visual, out success);
if (success)
{
result.Append(GetProjectionMatrix(visual.Camera, GetAspectRatio(visual.Viewport.Size)));
result.Append(GetHomogeneousToViewportTransform(visual.Viewport));
}
return(result);
}
