Ejemplo n.º 1
0
 public void OnLeftMousePressed(Vector2 mousePos)
 {
     if (Keyboard.IsKeyDown(Key.A))
     {
         dragMode = MouseDragMode.CameraRadiusChange;
     }
     else if (Keyboard.IsKeyDown(Key.LeftCtrl))
     {
         dragMode = MouseDragMode.CameraRotate;
     }
     else if (Keyboard.IsKeyDown(Key.LeftAlt))
     {
         dragMode = MouseDragMode.CameraMove;
     }
     else if (Keyboard.IsKeyDown(Key.C))
     {
         dragMode = MouseDragMode.CursorMove;
     }
     else if (Keyboard.IsKeyDown(Key.S))
     {
         dragMode          = MouseDragMode.SelectPoints;
         dragStartPosition = dragActualPosition = MousePosition;
     }
     else // dragging point
     {
         CatPoint clicked;
         if (SelectClickedPoint(mousePos, out clicked))
         {
             dragMode     = MouseDragMode.PointMove;
             draggedPoint = clicked;
             pointPlane   = new Plane(draggedPoint.Position, (draggedPoint.Position - ActiveCamera.CameraPosition).Normalized());
         }
     }
 }
Ejemplo n.º 2
0
 internal void Replace(CatPoint replacement)
 {
     if (this != replacement)
     {
         OnReplace?.Invoke(this, replacement);
     }
 }
Ejemplo n.º 3
0
        internal CatPoint CreateHiddenCatPoint(Vector3 pos)
        {
            var point = new CatPoint(pos);

            hiddenPoints.Add(point);

            return(point);
        }
Ejemplo n.º 4
0
        private void ClearScene()
        {
            CatPoint.ResetID();
            Model.ResetId();

            Models.Clear();
            Points.Clear();
            hiddenPoints.Clear();
        }
Ejemplo n.º 5
0
 internal void RemovePoint(CatPoint point)
 {
     if (!point.Removeable)
     {
         return;
     }
     point.CleanUp();
     Points.Remove(point);
     hiddenPoints.Remove(point);
 }
Ejemplo n.º 6
0
        internal CatPoint CreateCatPoint(Vector3 pos, bool addToSelected = true)
        {
            var point = new CatPoint(pos);

            points.Add(point);

            if (addToSelected)
            {
                var selected = Models.Where(x => x.IsSelected).ToList();
                if (selected.Count > 0 && selected[0] is IChangeablePointCount)
                {
                    var p = (IChangeablePointCount)selected[0];
                    p.AddPoint(point);
                }
            }
            return(point);
        }
Ejemplo n.º 7
0
        private bool SelectClickedPoint(Vector2 position, out CatPoint model)
        {
            //Ray cameraRay = ActiveCamera.GetViewRay(position);
            List <ClickData> clicks = new List <ClickData>();
            var cameraMatrix        = ActiveCamera.ViewProjectionMatrix;
            var pos = ScreenSize * position;

            foreach (var point in GetPoints())
            {
                if (!point.Visible)
                {
                    continue;
                }
                var pt       = (cameraMatrix * new Vector4(point.Position)).ToNormalizedVector3();
                var dt       = new Vector2(pt.X, pt.Y) * ScreenSize - pos;
                var distance = dt.Length();
                if (distance < 8)
                {
                    clicks.Add(new ClickData(pt.Z, point));
                }
            }

            ClickData selected;

            selected.ClickedModel = null;
            if (clicks.Count > 0)
            {
                clicks.Sort((x, y) => y.Distance.CompareTo(x.Distance));

                var clicked = clicks.First();
                if (clicked.ClickedModel != null)
                {
                    selected = clicked;
                }
            }
            if (selected.ClickedModel != null)
            {
                model = selected.ClickedModel;
                return(true);
            }
            model = null;
            return(false);
        }
Ejemplo n.º 8
0
        public void OnLeftMouseReleased()
        {
            if (dragMode == MouseDragMode.SelectPoints)
            {
                var dragEnd = MousePosition;
                var minX    = System.Math.Min(dragEnd.X, dragStartPosition.X) / ScreenSize.X;
                var maxX    = System.Math.Max(dragEnd.X, dragStartPosition.X) / ScreenSize.X;
                var minY    = System.Math.Min(dragEnd.Y, dragStartPosition.Y) / ScreenSize.Y;
                var maxY    = System.Math.Max(dragEnd.Y, dragStartPosition.Y) / ScreenSize.Y;

                var ptsList      = new List <CatPoint>();
                var cameraMatrix = ActiveCamera.ViewProjectionMatrix;

                foreach (var catPoint in GetPoints().Where(x => x.Visible))
                {
                    var pt = (cameraMatrix * new Vector4(catPoint.Position)).ToNormalizedVector3() / 2 + 0.5f;
                    if (pt.X < maxX && pt.X > minX && pt.Y < maxY && pt.Y > minY)
                    {
                        ptsList.Add(catPoint);
                    }
                }
                if (!Keyboard.IsKeyDown(Key.LeftCtrl))
                {
                    foreach (var catPoint in Points)
                    {
                        catPoint.IsSelected = false;
                    }
                }
                foreach (var catPoint in ptsList)
                {
                    catPoint.IsSelected = true;
                }
            }
            dragMode     = MouseDragMode.None;
            draggedPoint = null;
        }
Ejemplo n.º 9
0
        public void LoadFromFile(string filename)
        {
            var   p = new XMLSerializer();
            Scene scene;

            try
            {
                scene = p.DeserializeFromFile(filename);
            }
            catch (Exception)
            {
                return;
            }


            ClearScene();

            var catPoints = new List <CatPoint>(scene.Points.Length);

            for (int i = 0; i < scene.Points.Length; i++)
            {
                var pos = scene.Points[i].Position;
                var pt  = CreateCatPoint(new Vector3(pos.X, pos.Y, pos.Z), false);
                pt.Name = scene.Points[i].Name;
                catPoints.Add(pt);
            }


            foreach (var bezierCurveC0 in scene.BezierCurvesC0)
            {
                var curve = new Bezier(bezierCurveC0.Points.Select(x => catPoints[x]), this)
                {
                    Name = bezierCurveC0.Name
                };
                if (bezierCurveC0.DisplayPolygonSpecified)
                {
                    curve.ShowPolygon = bezierCurveC0.DisplayPolygon;
                }
                AddNewModel(curve);
            }

            foreach (var bezierCurveC2 in scene.BezierCurvesC2)
            {
                var curve = new BezierC2(bezierCurveC2.Points.Select(x => catPoints[x]), this)
                {
                    Name = bezierCurveC2.Name
                };
                if (bezierCurveC2.DisplayPolygonSpecified)
                {
                    curve.ShowPolygon = bezierCurveC2.DisplayPolygon;
                }
                AddNewModel(curve);
            }

            foreach (var interpolationBezierCurveC2 in scene.InterpolationBezierCurvesC2)
            {
                var curve = new BsplineInterpolator(interpolationBezierCurveC2.Points.Select(x => catPoints[x]), this)
                {
                    Name = interpolationBezierCurveC2.Name
                };
                if (interpolationBezierCurveC2.DisplayPolygonSpecified)
                {
                    curve.ShowPolygon = interpolationBezierCurveC2.DisplayPolygon;
                }
                AddNewModel(curve);
            }

            foreach (var bezierSurfaceC0 in scene.BezierSurfacesC0)
            {
                var patches = new List <Patch>();
                var ptches  = new Patch[bezierSurfaceC0.PatchesV, bezierSurfaceC0.PatchesU];
                foreach (var bezierSurfaceC0Patch in bezierSurfaceC0.Patches)
                {
                    var pts = new CatPoint[4, 4];
                    for (int i = 0; i < 4; i++)
                    {
                        for (int j = 0; j < 4; j++)
                        {
                            pts[i, j] = catPoints[bezierSurfaceC0Patch.Points[j, i]];
                        }
                    }
                    var patch = new BezierPatch(pts)
                    {
                        ShowPolygon = false,
                        HeightDiv   = bezierSurfaceC0Patch.SurfaceDivisionsV,
                        WidthDiv    = bezierSurfaceC0Patch.SurfaceDivisionsU,
                        Name        = bezierSurfaceC0Patch.Name,
                        VPos        = bezierSurfaceC0Patch.PatchU,
                        UPos        = bezierSurfaceC0Patch.PatchV
                    };
                    AddNewModel(patch);
                    patches.Add(patch);
                    ptches[bezierSurfaceC0Patch.PatchV, bezierSurfaceC0Patch.PatchU] = patch;
                }


                var surfacePoints = patches.SelectMany(x => x.EnumerateCatPoints()).Distinct().ToList();
                var surface       = new Surface(SurfaceType.Bezier, ptches, surfacePoints, this, false, false)
                {
                    Name     = bezierSurfaceC0.Name,
                    PatchesU = bezierSurfaceC0.PatchesU,
                    PatchesV = bezierSurfaceC0.PatchesV,
                };
                AddNewModel(surface);
            }

            foreach (var bezierSurfaceC2 in scene.BezierSurfacesC2)
            {
                var patches = new List <Patch>();
                var ptches  = new Patch[bezierSurfaceC2.PatchesV, bezierSurfaceC2.PatchesU];

                foreach (var bezierSurfaceC2Patch in bezierSurfaceC2.Patches)
                {
                    var pts = new CatPoint[4, 4];
                    for (int i = 0; i < 4; i++)
                    {
                        for (int j = 0; j < 4; j++)
                        {
                            pts[i, j] = catPoints[bezierSurfaceC2Patch.Points[j, i]];
                        }
                    }
                    var patch = new BSplinePatch(pts)
                    {
                        ShowPolygon = false,
                        HeightDiv   = bezierSurfaceC2Patch.SurfaceDivisionsV,
                        WidthDiv    = bezierSurfaceC2Patch.SurfaceDivisionsU,
                        Name        = bezierSurfaceC2Patch.Name,
                        UPos        = bezierSurfaceC2Patch.PatchU,
                        VPos        = bezierSurfaceC2Patch.PatchV
                    };
                    AddNewModel(patch);
                    patches.Add(patch);
                    ptches[bezierSurfaceC2Patch.PatchV, bezierSurfaceC2Patch.PatchU] = patch;
                }
                var loopedV = true;
                var loopedU = true;


                for (int i = 0; i < 3; i++)
                {
                    var pat  = ptches[0, 0].GetCatPoint(i, 0);
                    var pat2 = ptches[0, bezierSurfaceC2.PatchesU - 1].GetCatPoint(i + 1, 0);
                    if (pat != pat2 ||
                        ptches[0, 0].GetCatPoint(i, 1) != ptches[0, bezierSurfaceC2.PatchesU - 1].GetCatPoint(i + 1, 1) ||
                        ptches[0, 0].GetCatPoint(i, 2) != ptches[0, bezierSurfaceC2.PatchesU - 1].GetCatPoint(i + 1, 2))
                    {
                        loopedU = false;
                        break;
                    }
                }

                if (loopedU)
                {
                    for (int i = 0; i < ptches.GetLength(0); i++)
                    {
                        if (ptches[i, 0].GetCatPoint(0, 3) != ptches[i, bezierSurfaceC2.PatchesU - 1].GetCatPoint(1, 3) ||
                            ptches[i, 0].GetCatPoint(1, 3) != ptches[i, bezierSurfaceC2.PatchesU - 1].GetCatPoint(2, 3) ||
                            ptches[i, 0].GetCatPoint(2, 3) != ptches[i, bezierSurfaceC2.PatchesU - 1].GetCatPoint(3, 3))
                        {
                            loopedU = false;
                            break;
                        }
                    }
                }

                for (int i = 0; i < 3; i++)
                {
                    if (ptches[0, 0].GetCatPoint(0, i) != ptches[bezierSurfaceC2.PatchesV - 1, 0].GetCatPoint(0, i + 1) ||
                        ptches[0, 0].GetCatPoint(0, i) != ptches[bezierSurfaceC2.PatchesV - 1, 0].GetCatPoint(0, i + 1) ||
                        ptches[0, 0].GetCatPoint(0, i) != ptches[bezierSurfaceC2.PatchesV - 1, 0].GetCatPoint(0, i + 1))
                    {
                        loopedV = false;
                        break;
                    }
                }

                if (loopedV)
                {
                    for (int i = 0; i < ptches.GetLength(1); i++)
                    {
                        if (ptches[0, i].GetCatPoint(3, 0) != ptches[bezierSurfaceC2.PatchesV - 1, i].GetCatPoint(3, 1) ||
                            ptches[0, i].GetCatPoint(3, 1) != ptches[bezierSurfaceC2.PatchesV - 1, i].GetCatPoint(3, 2) ||
                            ptches[0, i].GetCatPoint(3, 2) != ptches[bezierSurfaceC2.PatchesV - 1, i].GetCatPoint(3, 3))
                        {
                            loopedV = false;
                            break;
                        }
                    }
                }
                if (loopedU == loopedV)
                {
                    Console.WriteLine($"Surf: {bezierSurfaceC2.Name}");
                }

                var surfacePoints = patches.SelectMany(x => x.EnumerateCatPoints()).Distinct().ToList();
                var surface       = new Surface(SurfaceType.BSpline, ptches, surfacePoints, this, loopedU, loopedV)
                {
                    Name     = bezierSurfaceC2.Name,
                    PatchesU = bezierSurfaceC2.PatchesU,
                    PatchesV = bezierSurfaceC2.PatchesV
                };
                AddNewModel(surface);
            }
        }
Ejemplo n.º 10
0
 internal PointWrapper(DataStructures.CatPoint point)
 {
     this.point = point;
 }