示例#1
0
        protected override void onReleaseOculusTrigger(ref VREvent_t vrEvent)
        {
            if (currentState == State.DRAW)
            {
                //simplfy the curve first before doing next interaction
                if (((Geometry.GeometryStroke)(stroke_g)).mPoints.Count >= 2)
                {
                    simplifyCurve(ref ((Geometry.GeometryStroke)(stroke_g)).mPoints);

                    //add to Scene curve object ,targetRhobj and check the next interaction

                    //since dynamicRender  == "none" then it didn't enter generateModel function
                    if (dynamicRender == "none")
                    {
                        if (drawnType != DrawnType.In3D && curveOnObjRef != null)
                        {
                            //simplifyCurve(ref ((Geometry.GeometryStroke)(stroke_g)).mPoints);
                            simplifiedCurve.SetUserString(CurveData.CurveOnObj.ToString(), curveOnObjRef.ObjectId.ToString());
                        }

                        localListCurve.Add(simplifiedCurve);
                    }

                    //generate new curveOnObj for mvoingPlane cases and move all moveplanes back to original position later
                    if (drawnType == DrawnType.Plane)
                    {
                        Rhino.Geometry.Vector3d newNormal = new Rhino.Geometry.Vector3d();;
                        Point3d newOrigin = new Point3d();
                        if (curveOnObjRef.Object().Attributes.Name.Contains("planeXY"))
                        {
                            newNormal = new Rhino.Geometry.Vector3d(0, 0, 1);
                            newOrigin = new Point3d(0, 0, curveOnObjRef.Object().Geometry.GetBoundingBox(true).Center.Z);
                        }
                        else if (curveOnObjRef.Object().Attributes.Name.Contains("planeYZ"))
                        {
                            newNormal = new Rhino.Geometry.Vector3d(1, 0, 0);
                            newOrigin = new Point3d(curveOnObjRef.Object().Geometry.GetBoundingBox(true).Center.X, 0, 0);
                        }
                        else if (curveOnObjRef.Object().Attributes.Name.Contains("planeXZ"))
                        {
                            newNormal = new Rhino.Geometry.Vector3d(0, 1, 0);
                            newOrigin = new Point3d(0, curveOnObjRef.Object().Geometry.GetBoundingBox(true).Center.Y, 0);
                        }

                        Plane        newPlane      = new Plane(newOrigin, newNormal);
                        int          size          = 240;
                        PlaneSurface plane_surface = new PlaneSurface(newPlane, new Interval(-size, size), new Interval(-size, size));
                        Brep         newPlaneBrep  = Brep.CreateFromSurface(plane_surface);

                        Guid newPlaneID = UtilOld.addRhinoObject(ref mScene, ref newPlaneBrep, "MoveP");
                        curveOnObjRef = null;
                        curveOnObjRef = new ObjRef(newPlaneID);

                        //update curveOnObj to new plane
                        if (localListCurve.Count > 0)
                        {
                            localListCurve[localListCurve.Count - 1].SetUserString(CurveData.CurveOnObj.ToString(), curveOnObjRef.ObjectId.ToString());
                        }
                        else
                        {
                            localListCurve.Add(simplifiedCurve);
                            localListCurve[localListCurve.Count - 1].SetUserString(CurveData.CurveOnObj.ToString(), curveOnObjRef.ObjectId.ToString());
                        }
                    }

                    //call next interaction in the chain
                    //testing if mScene.iCurveList update

                    /*
                     * mScene.iCurveList.Clear();
                     * for (int i =0; i < localListCurve.Count; i++)
                     * {
                     *  mScene.iCurveList.Add(localListCurve[i]);
                     * }*/

                    currentState    = State.END;
                    afterCurveCount = localListCurve.Count;
                    if (dynamicRender != "none" && backgroundStart == false)
                    {
                        backgroundStart = true;
                        R = d.BeginInvoke(new AsyncCallback(modelCompleted), null);
                    }
                    else if (dynamicRender == "none")
                    {
                        mScene.pushInteractionFromChain();
                    }
                    //mScene.pushInteractionFromChain();
                    //curveOnObjRef = null;
                }
            }
        }
示例#2
0
        protected override void onClickOculusAX(ref VREvent_t vrEvent)
        {
            //TODO-support projection curve
            Point3d planeCenter = new Point3d();

            if (!isProjection)
            {
                Brep[] shapes = Brep.CreatePlanarBreps(modelcurve);
                modelBrep = shapes[0];
                //Util.addRhinoObjectSceneNode(ref mScene, ref modelBrep, ref mesh_m, shapeType.ToString(), out renderObjSN);
                UtilOld.addSceneNode(ref mScene, ref modelBrep, ref mesh_m, shapeType.ToString(), out renderObjSN);

                if (shapeType == ShapeType.Circle)
                {
                    Circle circle;
                    if (modelcurve.TryGetCircle(out circle))
                    {
                        planeCenter = circle.Center;
                    }

                    mScene.iPointList.Add(UtilOld.platformToVRPoint(ref mScene, UtilOld.RhinoToOpenTKPoint(circle.Center)));
                    mScene.iPointList.Add(UtilOld.platformToVRPoint(ref mScene, UtilOld.RhinoToOpenTKPoint(circle.PointAt(0))));
                }
                else if (shapeType == ShapeType.Rect)
                {
                    Rhino.Geometry.Polyline polyline;
                    if (modelcurve.TryGetPolyline(out polyline))
                    {
                        Rectangle3d rect = Rectangle3d.CreateFromPolyline(polyline);
                        planeCenter = rect.Center;
                        mScene.iPointList.Add(UtilOld.platformToVRPoint(ref mScene, UtilOld.RhinoToOpenTKPoint(rect.Center)));
                        mScene.iPointList.Add(UtilOld.platformToVRPoint(ref mScene, UtilOld.RhinoToOpenTKPoint(rect.Corner(3))));
                    }
                }
            }

            //update modelPlane and use tolerance to support unplanar surface
            Plane  curvePlane = new Plane();
            Double tolerance  = 0;

            while (tolerance < 400)
            {
                if (modelcurve.TryGetPlane(out curvePlane, tolerance))
                {
                    modelPlane = curvePlane;
                    break;
                }
                tolerance++;
            }

            int          size          = 240;
            PlaneSurface plane_surface = new PlaneSurface(curvePlane, new Interval(-size, size), new Interval(-size, size));
            Brep         newPlaneBrep  = Brep.CreateFromSurface(plane_surface);

            Guid newPlaneID = UtilOld.addRhinoObject(ref mScene, ref newPlaneBrep, "3DP");

            //might be better to use Replace(), just need to be careful about the referece count
            pointOnObjRef = null;
            pointOnObjRef = new ObjRef(newPlaneID);

            //add icurveList since we don't use EditPoint2 for circle and rect
            modelcurve.SetUserString(CurveData.CurveOnObj.ToString(), newPlaneID.ToString());
            modelcurve.SetUserString(CurveData.PlaneOrigin.ToString(), curvePlane.Origin.ToString());
            modelcurve.SetUserString(CurveData.PlaneNormal.ToString(), curvePlane.Normal.ToString());
            mScene.iCurveList.Add(modelcurve);

            //call next interaction in the chain
            afterCurveCount = mScene.iCurveList.Count;
            mScene.pushInteractionFromChain();
        }
示例#3
0
        protected override void onClickOculusTrigger(ref VREvent_t vrEvent)
        {
            primaryDeviceIndex = vrEvent.trackedDeviceIndex;
            if (currentState != State.READY || targetPRhObjID == Guid.Empty)
            {
                return;
            }

            pointOnObjRef = new ObjRef(targetPRhObjID);
            //chage to only raycasting to the obj where we draw, if not snap to the origin
            if (!(projectP.X == 0 && projectP.Y == 0 && projectP.Z == 0))
            {
                rayCastingObjs.Clear();
                rayCastingObjs.Add(pointOnObjRef);
            }

            //testing
            Vector3 projectPVR = UtilOld.platformToVRPoint(ref mScene, UtilOld.RhinoToOpenTKPoint(projectP));

            mScene.iPointList.Add(UtilOld.platformToVRPoint(ref mScene, projectPVR)); //not use at the current version, point is VR coordinate
            pointsList.Add(projectP);

            //render edit points in VR
            Geometry.Geometry geo = new Geometry.DrawPointMarker(new Vector3(0, 0, 0));
            Material.Material m   = new Material.SingleColorMaterial(0, 1, 0, 1);
            SceneNode         editPointSN;

            UtilOld.MarkPointVR(ref mScene, projectPVR, ref geo, ref m, out editPointSN);
            pointMarkers.Add(editPointSN);

            //TODO-hide two other design plane
            if (pointMarkers.Count == 1)
            {
                if (pointOnObjRef != null && drawnType == DrawnType.Plane)
                {
                    if (!(projectP.X == 0 && projectP.Y == 0 && projectP.Z == 0))
                    {
                        UtilOld.hideOtherPlanes(ref mScene, pointOnObjRef.Object().Attributes.Name);
                    }
                    computeContourCurve();
                }
                //TODO- how to find the curvePlane on the surface like teapot body, using the normal of first point?
                //do we need to use different ways for patch surface and other generated surface
                else if (pointOnObjRef != null && drawnType == DrawnType.Surface)
                {
                    computeContourCurve();
                }
            }

            if (maxNumPoint == pointMarkers.Count)
            {
                //Assume we always can find a curvePlane sicnce we use a huge tolerance
                NurbsCurve modelcurve = null;
                Brep       modelBrep;
                string     modelName = "";
                if (shapeType == ShapeType.Circle)
                {
                    float  radius = (float)Math.Sqrt(Math.Pow(pointsList[1].X - pointsList[0].X, 2) + Math.Pow(pointsList[1].Y - pointsList[0].Y, 2) + Math.Pow(pointsList[1].Z - pointsList[0].Z, 2));
                    Circle circle = new Rhino.Geometry.Circle(curvePlane, pointsList[0], radius);
                    modelcurve = circle.ToNurbsCurve();
                    modelName  = "Circle";
                }
                else if (shapeType == ShapeType.Rect)
                {
                    Vector3 rectDiagonalV = new Vector3((float)(pointsList[0].X - pointsList[1].X), (float)(pointsList[0].Y - pointsList[1].Y), (float)(pointsList[0].Z - pointsList[1].Z));
                    float   lenDiagonal   = rectDiagonalV.Length;
                    Vector3 rectLeftTop   = new Vector3((float)pointsList[0].X, (float)pointsList[0].Y, (float)pointsList[0].Z) + lenDiagonal * rectDiagonalV.Normalized();
                    Point3d topLeftP      = new Point3d(rectLeftTop.X, rectLeftTop.Y, rectLeftTop.Z);

                    Rectangle3d rect = new Rectangle3d(curvePlane, topLeftP, pointsList[1]);

                    //using top-left cornel and bottom right

                    //Rectangle3d rect = new Rectangle3d(curvePlane, pointsList[0], pointsList[1]);

                    modelcurve = rect.ToNurbsCurve();
                    modelName  = "Rect";
                }

                /*
                 * Brep[] shapes = Brep.CreatePlanarBreps(modelcurve);
                 * modelBrep = shapes[0];
                 * Guid guid = Util.addRhinoObjectSceneNode(ref mScene, ref modelBrep, ref profile_m, modelName, out renderObjSN);
                 */

                //generate new curveOnObj for mvoingPlane cases sicne and move the XYZPlanes to origial positons
                if (drawnType == DrawnType.Plane)
                {
                    Rhino.Geometry.Vector3d newNormal = new Rhino.Geometry.Vector3d();;
                    Point3d newOrigin   = new Point3d();
                    String  planeName   = pointOnObjRef.Object().Attributes.Name;
                    Point3d planeOrigin = pointOnObjRef.Object().Geometry.GetBoundingBox(true).Center;
                    if (planeName.Contains("planeXY"))
                    {
                        newNormal = new Rhino.Geometry.Vector3d(0, 0, 1);
                        newOrigin = new Point3d(0, 0, planeOrigin.Z);
                    }
                    else if (planeName.Contains("planeYZ"))
                    {
                        newNormal = new Rhino.Geometry.Vector3d(1, 0, 0);
                        newOrigin = new Point3d(planeOrigin.X, 0, 0);
                    }
                    else if (planeName.Contains("planeXZ"))
                    {
                        newNormal = new Rhino.Geometry.Vector3d(0, 1, 0);
                        newOrigin = new Point3d(0, planeOrigin.Y, 0);
                    }

                    Plane        newPlane      = new Plane(newOrigin, newNormal);
                    int          size          = 240;
                    PlaneSurface plane_surface = new PlaneSurface(newPlane, new Interval(-size, size), new Interval(-size, size));
                    Brep         newPlaneBrep  = Brep.CreateFromSurface(plane_surface);

                    Guid newPlaneID = UtilOld.addRhinoObject(ref mScene, ref newPlaneBrep, "MoveP");
                    //might be better to use Replace(), just need to be careful about the referece count
                    pointOnObjRef = null;
                    pointOnObjRef = new ObjRef(newPlaneID);

                    modelcurve.SetUserString(CurveData.CurveOnObj.ToString(), newPlaneID.ToString());
                    modelcurve.SetUserString(CurveData.PlaneOrigin.ToString(), newPlane.Origin.ToString());
                    modelcurve.SetUserString(CurveData.PlaneNormal.ToString(), newPlane.Normal.ToString());
                }
                else if (drawnType == DrawnType.Surface)
                {
                    modelcurve.SetUserString(CurveData.CurveOnObj.ToString(), pointOnObjRef.ObjectId.ToString());
                    modelcurve.SetUserString(CurveData.PlaneOrigin.ToString(), curvePlane.Origin.ToString());
                    modelcurve.SetUserString(CurveData.PlaneNormal.ToString(), curvePlane.Normal.ToString());
                }

                mScene.iCurveList.Add(modelcurve);

                //call next interaction in the chain
                afterCurveCount = mScene.iCurveList.Count;
                mScene.pushInteractionFromChain();
                currentState = State.READY;
            }
        }