private void AddContours(Visual3D model1, int o, int m, int n)
 {
     var bounds = Visual3DHelper.FindBounds(model1, Transform3D.Identity);
     for (int i = 1; i < n; i++)
     {
         this.ContourPlane = new Plane3D(new Point3D(0, 0, bounds.Location.Z + bounds.Size.Z * i / n), new Vector3D(0, 0, 1));
         Visual3DHelper.Traverse<GeometryModel3D>(model1, this.AddContours);
     }
     for (int i = 1; i < m; i++)
     {
         this.ContourPlane = new Plane3D(new Point3D(0, bounds.Location.Y + bounds.Size.Y * i / m, 0), new Vector3D(0, 1, 0));
         Visual3DHelper.Traverse<GeometryModel3D>(model1, this.AddContours);
     }
     for (int i = 1; i < o; i++)
     {
         this.ContourPlane = new Plane3D(new Point3D(bounds.Location.X + bounds.Size.X * i / o, 0, 0), new Vector3D(1, 0, 0));
         Visual3DHelper.Traverse<GeometryModel3D>(model1, this.AddContours);
     }
 }

 public ManipulatorControl(ManipulatorType type, Visual3D visual)
 {
     targetVisual = visual;
     Type = type;
     Transform = targetVisual.Transform;
     Diameter = 0.5;
     double l = 5;
     switch (type)
     {
         case ManipulatorType.TranslateX:
             Normal = new Vector3D(0, 0, 1);
             Direction = new Vector3D(l, 0, 0);
             Fill = Brushes.Red;
             break;
         case ManipulatorType.TranslateY:
             Normal = new Vector3D(0, 0, 1);
             Direction = new Vector3D(0, l, 0);
             Fill = Brushes.Green;
             break;
         case ManipulatorType.TranslateZ:
             Normal = new Vector3D(0, 1, 0);
             Direction = new Vector3D(0, 0, l);
             Fill = Brushes.Blue;
             break;
     }
 }

 public BlipVisual(Visual3D visual, bool isVisualUpright, TranslateTransform3D translate, AxisAngleRotation3D rotate)
 {
     this.Visual = visual;
     this.IsVisualUpright = isVisualUpright;
     this.Translate = translate;
     this.Rotate = rotate;
 }

 public void Export(Visual3D visual)
 {
     object obj = visual;
     if (CreateResourceDictionary)
         obj = WrapInResourceDictionary(obj);
     XamlWriter.Save(obj, xw);
 }

 public static void RemoveChild(DependencyObject parent, Visual3D v3d)
 {
     var parentAsModelVisual3D = parent as ModelVisual3D;
     if (parentAsModelVisual3D != null)
     {
         parentAsModelVisual3D.Children.Remove(v3d);
     }
 }

 public Visual3DClickedEventArgs(Visual3D visual, MouseButtonState left, MouseButtonState right, bool hasMoved, Point position)
 {
     _Visual = visual;
     _LeftButton = left;
     _RightButton = right;
     _HasMoved = hasMoved;
     _MousePosition = position;
 }

 public Point3D? HitTest(Visual3D reference, Point3D point, Vector3D direction)
 {
     if (reference != null)
     {
         var hitParams = new RayHitTestParameters(point, direction);
         hit = false;
         VisualTreeHelper.HitTest(reference, null, HitTestCallback, hitParams);
         if (hit)
         {
             return hitTestValue;
         }
     }
     return null;
 }

        /// <summary>
        /// Determines whether the specified visual is transparent.
        /// </summary>
        /// <param name="v">The v.</param>
        /// <returns>
        /// 	<c>true</c> if the specified visual is transparent; otherwise, <c>false</c>.
        /// </returns>
        public static bool IsTransparent(Visual3D v)
        {
            var mv3D = v as ModelVisual3D;
            if (mv3D != null)
            {
                // check if Model3D is transparent
                if (IsTransparent(mv3D.Content))
                    return true;

                // check if any child Visual3D are transparent
                return mv3D.Children.Any(IsTransparent);
            }

            return false;
        }

        /// <summary>
        /// Create a clone of a Visual3D
        /// </summary>
        /// <param name="v">
        /// a Visual3D
        /// </param>
        /// <returns>
        /// the clone
        /// </returns>
        public static Visual3D CreateClone(Visual3D v)
        {
            if (v is ModelUIElement3D)
            {
                var m = v as ModelUIElement3D;
                if (m.Model != null)
                {
                    /*if (m.Model.CanFreeze)
                        m.Model.Freeze();
                    if (m.Model.IsFrozen)*/
                    {
                        var clonedModel = m.Model.Clone();
                        var clonedElement = new ModelUIElement3D();
                        clonedElement.Transform = m.Transform;
                        clonedElement.Model = clonedModel;
                        return clonedElement;
                    }
                }
            }

            if (v is ModelVisual3D)
            {
                var m = v as ModelVisual3D;
                var clone = new ModelVisual3D();
                clone.Transform = m.Transform;
                if (m.Content != null && m.Content.CanFreeze)
                {
                    m.Content.Freeze();
                    var clonedModel = m.Content.Clone();
                    clone.Content = clonedModel;
                }

                if (m.Children.Count > 0)
                {
                    foreach (var child in m.Children)
                    {
                        var clonedChild = CreateClone(child);
                        clone.Children.Add(clonedChild);
                    }
                }

                return clone;
            }

            return null;
        }

        //------------------------------------------------------
        //
        //  Constructors
        //
        //------------------------------------------------------

        #region Constructors

        internal RayMeshGeometry3DHitTestResult(
            Visual3D visualHit,
            Model3D modelHit,
            MeshGeometry3D meshHit,
            Point3D pointHit,
            double distanceToRayOrigin, 
            int vertexIndex1,
            int vertexIndex2,
            int vertexIndex3,
            Point barycentricCoordinate) : base (visualHit, modelHit)
            {
                _meshHit = meshHit;
                _pointHit = pointHit;
                _distanceToRayOrigin = distanceToRayOrigin;
                _vertexIndex1 = vertexIndex1;
                _vertexIndex2 = vertexIndex2;
                _vertexIndex3 = vertexIndex3;
                _barycentricCoordinate = barycentricCoordinate;
            }

        /// <summary>
        /// Propagates the flags up to the root.
        /// </summary>
        /// <remarks>
        /// The walk stops on a node with all of the required flags set.
        /// </remarks>
        internal static void PropagateFlags(
            Visual3D e, 
            VisualFlags flags,
            VisualProxyFlags proxyFlags)
        {
            while ((e != null) && 
                   (!e.CheckFlagsAnd(flags) || !e.CheckFlagsOnAllChannels(proxyFlags)))
            {
                // These asserts are mostly for documentation when diffing the 2D/3D
                // implementations.
                Debug.Assert(!e.CheckFlagsOr(VisualFlags.ShouldPostRender),
                    "Visual3Ds should never be the root of a tree.");
                 Debug.Assert(!e.CheckFlagsOr(VisualFlags.NodeIsCyclicBrushRoot),
                    "Visual3Ds should never be the root of an ICyclicBrush.");

                e.SetFlags(true, flags);
                e.SetFlagsOnAllChannels(true, proxyFlags);

                // If our 3D parent is null call back into VisualTreeUtils to potentially
                // continue the walk in 2D.
                if (e._3DParent == null)
                {
                    Viewport3DVisual viewport = e.InternalVisualParent as Viewport3DVisual;

                    Debug.Assert((viewport == null) == (e.InternalVisualParent == null),
                        "Viewport3DVisual is the only supported 2D parent of a 3D visual.");
                    
                    if(viewport != null)
                    {
                        // We must notify the 2D visual that its contents have changed.
                        // This will cause the 2D visual to set it's content dirty flag
                        // and continue the propagation of IsDirtyForRender/Precompute.
                        viewport.Visual3DTreeChanged();

                        // continue propagating flags up the 2D world
                        Visual.PropagateFlags(viewport, flags, proxyFlags);
                    }
                        
                    // Stop propagating.  We are at the root of the 3D subtree.
                    return;
                }

                e = e._3DParent;
            }
        }

        /// <summary>
        ///     Check all the children for a bit.
        /// </summary>
        internal static bool DoAnyChildrenHaveABitSet(Visual3D pe,
                                                      VisualFlags flag)
        {

            int count = pe.InternalVisual2DOr3DChildrenCount;
            for (int i = 0; i < count; i++)
            {
                DependencyObject child = pe.InternalGet2DOr3DVisualChild(i);
                                
                Visual v = null;
                Visual3D v3D = null;
                VisualTreeUtils.AsNonNullVisual(child, out v, out v3D);
                
                if (v != null && v.CheckFlagsAnd(flag))
                {
                    return true;
                }
                else if (v3D != null && v3D.CheckFlagsAnd(flag))
                {
                    return true;
                }
            }

            return false;
        }

        /// <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; 
            }
        } 

        /// <summary> 
        /// Gets the object space to world space transformation for the given Visual3D
        /// </summary>
        /// <param name="visual">The visual whose world space transform should be found</param>
        /// <returns>The world space transformation</returns> 
        internal static Matrix3D GetWorldTransformationMatrix(Visual3D visual)
        { 
            Viewport3DVisual ignored; 

            return GetWorldTransformationMatrix(visual, out ignored); 
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="BillboardGeometryBuilder"/> class.
 /// </summary>
 /// <param name="visual">
 /// The visual.
 /// </param>
 public BillboardGeometryBuilder(Visual3D visual)
     : base(visual)
 {
 }

 /// <summary>
 /// Gets the distance from the camera for the specified visual.
 /// </summary>
 /// <param name="c">
 /// The visual.
 /// </param>
 /// <param name="cameraPos">
 /// The camera position.
 /// </param>
 /// <param name="transform">
 /// The total transform of the visual.
 /// </param>
 /// <returns>
 /// The camera distance.
 /// </returns>
 private double GetCameraDistance(Visual3D c, Point3D cameraPos, Transform3D transform)
 {
     var bounds = Visual3DHelper.FindBounds(c, transform);
     switch (this.Method)
     {
         case SortingMethod.BoundingBoxCenter:
             var mid = new Point3D(
                 bounds.X + bounds.SizeX * 0.5, bounds.Y + bounds.SizeY * 0.5, bounds.Z + bounds.SizeZ * 0.5);
             return (mid - cameraPos).LengthSquared;
         case SortingMethod.BoundingBoxCorners:
             double d = double.MaxValue;
             d = Math.Min(d, cameraPos.DistanceTo(new Point3D(bounds.X, bounds.Y, bounds.Z)));
             d = Math.Min(d, cameraPos.DistanceTo(new Point3D(bounds.X + bounds.SizeX, bounds.Y, bounds.Z)));
             d = Math.Min(
                 d, cameraPos.DistanceTo(new Point3D(bounds.X + bounds.SizeX, bounds.Y + bounds.SizeY, bounds.Z)));
             d = Math.Min(d, cameraPos.DistanceTo(new Point3D(bounds.X, bounds.Y + bounds.SizeY, bounds.Z)));
             d = Math.Min(d, cameraPos.DistanceTo(new Point3D(bounds.X, bounds.Y, bounds.Z + bounds.SizeZ)));
             d = Math.Min(
                 d, cameraPos.DistanceTo(new Point3D(bounds.X + bounds.SizeX, bounds.Y, bounds.Z + bounds.SizeZ)));
             d = Math.Min(
                 d,
                 cameraPos.DistanceTo(
                     new Point3D(bounds.X + bounds.SizeX, bounds.Y + bounds.SizeY, bounds.Z + bounds.SizeZ)));
             d = Math.Min(
                 d, cameraPos.DistanceTo(new Point3D(bounds.X, bounds.Y + bounds.SizeY, bounds.Z + bounds.SizeZ)));
             return d;
         default:
             var boundingSphere = BoundingSphere.CreateFromRect3D(bounds);
             return boundingSphere.DistanceFrom(cameraPos);
     }
 }

        internal void SetParent(Visual3D newParent)
        {
            _2DParent.ClearValue(this);
            _3DParent = newParent;

            Debug.Assert(InternalVisualParent == newParent);
        }

        //------------------------------------------------------
        //
        //  Public Properties
        //
        //------------------------------------------------------
        
        //------------------------------------------------------
        //
        //  Public Events
        //
        //------------------------------------------------------

        //------------------------------------------------------
        //
        //  Protected Methods
        //
        //------------------------------------------------------
        
        #region Protected Methods

        /// <summary>
        /// AttachChild
        ///
        ///    Derived classes must call this method to notify the Visual3D layer that a new
        ///    child appeard in the children collection. The Visual3D layer will then call the GetVisual3DChild
        ///    method to find out where the child was added.
        ///
        ///  Remark: To move a Visual3D child in a collection it must be first disconnected and then connected
        ///    again. (Moving forward we might want to add a special optimization there so that we do not
        ///    unmarshal our composition resources).
        /// </summary>
        protected void AddVisual3DChild(Visual3D child)
        {            
            // It is invalid to modify the children collection that we 
            // might be iterating during a property invalidation tree walk.
            if (IsVisualChildrenIterationInProgress)
            {
                throw new InvalidOperationException(SR.Get(SRID.CannotModifyVisualChildrenDuringTreeWalk));
            }

            Debug.Assert(child != null);
            Debug.Assert(child.InternalVisualParent == null);

            child.SetParent(this);
            
            // set the inheritance context so databinding, etc... work
            ProvideSelfAsInheritanceContext(child, null);
            
            // The child already might be dirty. Hence we need to propagate dirty information
            // from the parent and from the child.
            Visual3D.PropagateFlags(
                this, 
                VisualFlags.IsSubtreeDirtyForPrecompute, 
                VisualProxyFlags.IsSubtreeDirtyForRender);

            Visual3D.PropagateFlags(
                child, 
                VisualFlags.IsSubtreeDirtyForPrecompute, 
                VisualProxyFlags.IsSubtreeDirtyForRender);

            // 


            // Fire notifications
            OnVisualChildrenChanged(child, /* visualRemoved = */ null);
            
            child.FireOnVisualParentChanged(null);
        }

        /// <summary>
        /// DisconnectChild
        ///
        ///    Derived classes must call this method to notify the Visual3D layer that a
        ///    child was removed from the children collection. The Visual3D layer will then call
        ///    GetVisual3DChild to find out which child has been removed.
        ///
        /// </summary>
        protected void RemoveVisual3DChild(Visual3D child)
        {
            // It is invalid to modify the children collection that we 
            // might be iterating during a property invalidation tree walk.
            if (IsVisualChildrenIterationInProgress)
            {
                throw new InvalidOperationException(SR.Get(SRID.CannotModifyVisualChildrenDuringTreeWalk));
            }

            Debug.Assert(child != null);
            Debug.Assert(child.InternalVisualParent == this);

            child.SetParent(/* newParent = */ (Visual3D) null);  // CS0121: Call is ambigious without casting null to Visual3D.
                    
            // remove the inheritance context
            RemoveSelfAsInheritanceContext(child, null);
                        
            //
            // Remove the child on all the channels 
            // this visual is being marshalled to.
            //

            for (int i = 0, limit = _proxy.Count; i < limit; i++) 
            {
                DUCE.Channel channel = _proxy.GetChannel(i);

                if (child.CheckFlagsAnd(channel, VisualProxyFlags.IsConnectedToParent))
                {
                    child.SetFlags(channel, false, VisualProxyFlags.IsConnectedToParent);
                    DUCE.IResource childResource = (DUCE.IResource)child;
                    childResource.RemoveChildFromParent(this, channel);
                    childResource.ReleaseOnChannel(channel);
                }
            }

            //
            // Force a full precompute and render pass for this visual.
            //

            Visual3D.PropagateFlags(
                this, 
                VisualFlags.IsSubtreeDirtyForPrecompute,
                VisualProxyFlags.IsSubtreeDirtyForRender);

            // 


            // Fire notifications
            child.FireOnVisualParentChanged(this);

            OnVisualChildrenChanged(/* visualAdded = */ null , child);
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="LineGeometryBuilder"/> class.
 /// </summary>
 /// <param name="visual">
 /// The visual parent of the geometry (the transform is calculated from this object).
 /// </param>
 public LineGeometryBuilder(Visual3D visual)
     : base(visual)
 {
 }