Silverlight3D 墙效果

using System;
using System.ComponentModel;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Threading;

namespace Silverlight3D
{
        public class Panel3D : Panel
        {
                private Point mouseStart, mouseNow;
                private double destinationDistance = 800;

                public enum AlignmentOptions { Left, Center, Right };

                private const double MouseWheelScaleFactor = 2.5;
                private const double Easing = 0.3;
                private const double MaximumDistance = 3000;
                private const double MinimumDistance = 200;
                private const double MouseEasing = 0.03;

                #region Dependency Properties

                public static readonly DependencyProperty RadiusProperty = DependencyProperty.Register("Radius", typeof(double), typeof(CircularPanel3D), new PropertyMetadata(CircularPanel3D.RadiusChanged));
                public static readonly DependencyProperty AngleItemProperty = DependencyProperty.Register("AngleItem", typeof(double), typeof(CircularPanel3D), new PropertyMetadata(CircularPanel3D.AngleItemChanged));
                public static readonly DependencyProperty InitialAngleProperty = DependencyProperty.Register("InitialAngle", typeof(double), typeof(CircularPanel3D), new PropertyMetadata(CircularPanel3D.InitialAngleChanged));
                public static readonly DependencyProperty AlignProperty = DependencyProperty.Register("Align", typeof(AlignmentOptions), typeof(CircularPanel3D), new PropertyMetadata(CircularPanel3D.AlignChanged));
                public static readonly DependencyProperty IsDragOnProperty = DependencyProperty.Register("IsDragOn", typeof(bool), typeof(CircularPanel3D), new PropertyMetadata(CircularPanel3D.IsDragChanged));
                public static readonly DependencyProperty OffsetYProperty = DependencyProperty.Register("OffsetY", typeof(double), typeof(CircularPanel3D), new PropertyMetadata(CircularPanel3D.OffsetYChanged));
                public static readonly DependencyProperty DistanceProperty = DependencyProperty.Register("Distance", typeof(double), typeof(CircularPanel3D), new PropertyMetadata(CircularPanel3D.DistanceChanged));

                private static void RadiusChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e) { ((CircularPanel3D)sender).Refresh(); }
                private static void AngleItemChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e) { ((CircularPanel3D)sender).Refresh(); }
                private static void InitialAngleChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e) { ((CircularPanel3D)sender).Refresh(); }
                private static void AlignChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e) { ((CircularPanel3D)sender).Refresh(); }
                private static void IsDragChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e) { ((CircularPanel3D)sender).OnIsDragChanged(e); }
                private static void OffsetYChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e) { ((CircularPanel3D)sender).Refresh(); }
                private static void DistanceChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e) 
                {
                        CircularPanel3D circularPanel3D = (CircularPanel3D)sender;
                        circularPanel3D.destinationDistance = (double)e.NewValue;
                        circularPanel3D.Refresh();
                }

                [Category("Circular Panel 3D")]
                public double Radius
                {
                        get { return (double)this.GetValue(CircularPanel3D.RadiusProperty); }
                        set { this.SetValue(CircularPanel3D.RadiusProperty, value); }
                }

                [Category("Circular Panel 3D")]
                public double AngleItem
                {
                        get { return (double)this.GetValue(CircularPanel3D.AngleItemProperty); }
                        set { this.SetValue(CircularPanel3D.AngleItemProperty, value); }
                }

                [Category("Circular Panel 3D")]
                public double InitialAngle
                {
                        get { return (double)this.GetValue(CircularPanel3D.InitialAngleProperty); }
                        set { this.SetValue(CircularPanel3D.InitialAngleProperty, value); }
                }

                [Category("Circular Panel 3D")]
                public AlignmentOptions Align
                {
                        get { return (AlignmentOptions)this.GetValue(CircularPanel3D.AlignProperty); }
                        set { this.SetValue(CircularPanel3D.AlignProperty, value); }
                }

                [Category("Circular Panel 3D")]
                public bool IsDragOn
                {
                        get { return (bool)this.GetValue(CircularPanel3D.IsDragOnProperty); }
                        set { this.SetValue(CircularPanel3D.IsDragOnProperty, value); }
                }

                [Category("Circular Panel 3D")]
                public double OffsetY
                {
                        get { return (double)this.GetValue(CircularPanel3D.OffsetYProperty); }
                        set { this.SetValue(CircularPanel3D.OffsetYProperty, value); }
                }

                [Category("Circular Panel 3D")]
                public double Distance
                {
                        get { return (double)this.GetValue(CircularPanel3D.DistanceProperty); }
                        set { this.SetValue(CircularPanel3D.DistanceProperty, value); }
                }

                #endregion

                #region Dependency Property Events

                private void OnIsDragChanged(DependencyPropertyChangedEventArgs e)
                {
                        this.CaptureMouse();
                        this.MouseLeftButtonDown += new MouseButtonEventHandler(this.CircularPanel3D_MouseLeftButtonDown);
                        this.MouseLeftButtonUp += new MouseButtonEventHandler(this.CircularPanel3D_MouseLeftButtonUp);
                }

                #endregion

                #region Mouse Interaction

                private void CircularPanel3D_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
                {
                        this.CaptureMouse();
                        this.mouseStart = e.GetPosition(this);
                        this.mouseNow = this.mouseStart;

                        CompositionTarget.Rendering += this.ApplyRotationFromMouseMove;

                        this.MouseMove += new MouseEventHandler(this.CircularPanel3D_MouseMove);
                }

                private void CircularPanel3D_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
                {
                        this.ReleaseMouseCapture();
                        this.MouseMove -= new MouseEventHandler(this.CircularPanel3D_MouseMove);
                }

                // Updates mouse position when mouse moves
                private void CircularPanel3D_MouseMove(object sender, MouseEventArgs e)
                {
                        CompositionTarget.Rendering += this.ApplyRotationFromMouseMove;

                        this.mouseNow = e.GetPosition(this);
                }

                private void HandleMouseWheel(object sender, MouseWheelEventArgs e)
                {
                        double newDistance = this.destinationDistance + CircularPanel3D.MouseWheelScaleFactor * -e.Delta;

                        if (newDistance <= CircularPanel3D.MaximumDistance && 
                                newDistance >= CircularPanel3D.MinimumDistance)
                        {
                                this.destinationDistance += CircularPanel3D.MouseWheelScaleFactor * -e.Delta;
                        }
                }

                private void ApplyZoomDistanceAnimation(object sender, EventArgs e)
                {
                        if (Math.Abs(this.Distance - destinationDistance) < 1)
                        {
                                this.Distance = destinationDistance;
                        }

                        this.Distance += (destinationDistance - this.Distance) * CircularPanel3D.Easing;
                        
                        if (this.Distance > CircularPanel3D.MaximumDistance)
                        {
                                this.destinationDistance = CircularPanel3D.MaximumDistance;
                        }
                        else if (this.Distance < CircularPanel3D.MinimumDistance)
                        {
                                this.destinationDistance = CircularPanel3D.MinimumDistance;
                        }
                }

                #endregion
                
                #region Custom Panel Methods

                protected override Size MeasureOverride(Size availableSize)
                {
                        this.MouseWheel += this.HandleMouseWheel;
                        CompositionTarget.Rendering += this.ApplyZoomDistanceAnimation;

                        Size resultSize = new Size(0, 0);

                        foreach (UIElement child in this.Children)
                        {
                                child.Measure(availableSize);
                                resultSize.Width = Math.Max(resultSize.Width, child.DesiredSize.Width);
                                resultSize.Height = Math.Max(resultSize.Height, child.DesiredSize.Height);
                        }

                        resultSize.Width =
                                double.IsPositiveInfinity(availableSize.Width) ?
                                resultSize.Width : availableSize.Width;

                        resultSize.Height =
                                double.IsPositiveInfinity(availableSize.Height) ?
                                resultSize.Height : availableSize.Height;

                        return resultSize;
                }

                protected override Size ArrangeOverride(Size finalSize)
                {
                        this.Refresh();
                        return base.ArrangeOverride(finalSize);
                }

                #endregion

                #region Programmatic Animation Methods

                private void ApplyRotationFromMouseMove(object sender, EventArgs e)
                {
                        // Rotates Circular Panel 3D using MouseMove (X)
                        if (Math.Abs(this.mouseNow.X - this.mouseStart.X) < 1)
                        {
                                this.mouseNow.X = this.mouseStart.X;
                        }
                        this.InitialAngle += ((this.mouseNow.X - this.mouseStart.X) * CircularPanel3D.MouseEasing) / 2.2;

                        this.mouseStart.X += ((this.mouseNow.X - this.mouseStart.X) * CircularPanel3D.MouseEasing);
                        if ((Math.Abs(this.mouseNow.X - this.mouseStart.X) < 1))
                        {
                                CompositionTarget.Rendering -= this.ApplyRotationFromMouseMove;
                        }
                }

                private void Refresh()
                {
                        int count = 0;
                        int col = 0;
                        int row = 0;
                        int zLevel = 0;

                        foreach (FrameworkElement childElement in this.Children)
                        {
                                double angle = (this.AngleItem * count++) - this.InitialAngle;
                                double x = this.Radius * Math.Cos(Math.PI * angle / 180);
                                double z = this.Radius * Math.Sin(Math.PI * angle / 180);
                                PlaneProjection projection = new PlaneProjection();
                                if (projection != null)
                                {
                                        projection.CenterOfRotationX = 0.5;
                                        projection.CenterOfRotationY = 0.5;
                                        projection.CenterOfRotationZ = 0.5;
                                        projection.RotationY = angle + 90;
                                        projection.GlobalOffsetX = x;
                                        projection.GlobalOffsetZ = z - this.Distance;
                                        projection.GlobalOffsetY = row * (-330) + this.OffsetY;
                                }

                                int depth = (int)(z * 100);

                                double pDist = (this.Distance - 1000) / 2000;
                                double pZ = ((z + 1000) / 2000) + 0.5;

                                double opacity = (pZ - pDist) + 0.4;
                                if (opacity >= 1)
                                {
                                        childElement.Opacity = (2 - opacity);
                                }
                                else if (opacity < 0)
                                {
                                        childElement.Opacity = 0;
                                }
                                else
                                {
                                        childElement.Opacity = opacity;
                                }

                                // Variable zLevel changes value of ZIndex for each item in the ListBox.
                                // This way the reflex of elements at the top will be placed behind the item below it.
                                Canvas.SetZIndex(childElement, depth-(++zLevel*10));

                                double alignX = 0;
                                double alignY = 0;
                                switch (this.Align)
                                {
                                        case AlignmentOptions.Left:
                                                alignX = 0;
                                                alignY = 0;
                                                break;
                                        case AlignmentOptions.Center:
                                                alignX = childElement.DesiredSize.Width / 2;
                                                alignY = childElement.DesiredSize.Height / 2;
                                                break;
                                        case AlignmentOptions.Right:
                                                alignX = childElement.DesiredSize.Width;
                                                alignY = childElement.DesiredSize.Height;
                                                break;
                                }
                                childElement.Projection = projection;
                                childElement.Arrange(new Rect(this.Width / 2 - alignX , this.Height / 2 - alignY, childElement.DesiredSize.Width, childElement.DesiredSize.Height));

                                col++;
                                if (col > 14)
                                {
                                        col = 0;
                                        row++;
                                }
                        }
                }

                #endregion
        }
}