示例#1
0
    void Start()
    {
        camera2d = GameObject.Find("Camera2d").GetComponent <Camera> ();
        VectorLine.SetCanvasCamera(camera2d);
        VectorLine.canvas3D.sortingLayerName = "World";

        gridLine = new VectorLine("Grid", new Vector2[0], null, 1.0f);
        drawLine = new VectorLine("DrawLine", new Vector3[0], null, 1.0f, isContinue? LineType.Continuous : LineType.Discrete, isContinue ? Joins.None : Joins.None);
        //drawLine.rectTransform.gameObject.AddComponent<Outline>();
        rulerLine      = new VectorLine("Ruler", new Vector3[0], null, 1.0f, LineType.Discrete);
        segmentOutline = new VectorLine("SegmentOutline", new Vector3[0], null, 1.0f, LineType.Discrete);
        segmentFill    = new WallFill(VectorLine.canvas3D, "SegmentFill");

        Vector2[] room = RoomQuad.GetVertex();
        //DrawWall(room);
        List <Wall2D> roomWalls = DrawHelper.ContinueToDiscrete(room);

        Home.Get().AddWallList(roomWalls);

//		VectorLine testLine = new VectorLine("test", new Vector3[] { Vector3.zero, new Vector3(1.0f, 0f, 0f), Vector3.one }, null, 2.0f, LineType.Continuous);
//		testLine.Draw3D();

        // Align 1-pixel lines on the pixel grid, so they don't potentially get messed up by anti-aliasing
        //gridLine.rectTransform.anchoredPosition = new Vector2 (.5f, .5f);
        gridLine.rectTransform.anchoredPosition = new Vector2(0f, 0f);
        //MakeGrid ();

        //SetScale(DrawHelper.unitPixels);
        DrawHelper.OnScaleChanged = MakeGrid2;
        DrawHelper.SetScale(camera2d, DrawHelper.unitPixels);

        mState = State2D.Idle;
    }
示例#2
0
        public MainWindow()
        {
            InitializeComponent();

            double r = 0.1;
            double d = 0.5;

            SimulatedRobotModel robot = new SimulatedRobotModel(r, d);

            State2D currState = new State2D(0.0, 0.0, 0.0);
            State2D goalState = new State2D(5.0, 5.0, 0.0);

            //State2D_Difference err = new State2D_Difference(currState, goalState);

            //BodyFrameCommands cmdBody = new BodyFrameCommands(0.1, 0.0);
            //WheelCommands cmdWheel = cmdBody.GetWheelCommands(r, d);

            //robot.SetWheelVelocityDesired(cmdWheel.OmegaL * r, cmdWheel.OmegaR * r);
            robot.CalculateWheelVelocity();

            State2D state = robot.Propagate(new State2D(), 1.0, robot.Vl, robot.Vr);

            int i = 0;

            while (i < 1000)
            {
                State2D_Difference err = new State2D_Difference(currState, goalState);

                WheelCommands cmdWheel = robot.StateController.GetCommands(err);

                robot.SetWheelVelocityDesired(cmdWheel.OmegaL * r, cmdWheel.OmegaR * r);
                robot.CalculateWheelVelocity();

                currState = robot.Propagate(currState, 0.1, robot.Vl, robot.Vr);

                i++;
            }
        }
示例#3
0
    void Awake()
    {
        Canvas canvas2d = VectorLine.canvas;
        GraphicRaycaster graphicRaycaster = canvas2d.gameObject.AddComponent<GraphicRaycaster>();
        graphicRaycaster.blockingObjects = GraphicRaycaster.BlockingObjects.ThreeD;

        Button drawBtn = GameObject.Find("UIRoot/DrawBtn").GetComponent<Button>();

        bool clicked = false;

        drawBtn.onClick.AddListener(() => {
            clicked  = !clicked;
            Debug.Log("On DrawBtn clicked.." + clicked);

            if(clicked){
                if(this.mState != State2D.Draw){
                    this.mState = State2D.Draw;
                }
            }
            else{
                if(this.mState == State2D.Draw){
                    this.mState = State2D.Idle;
                }
            }
        });

        GameObject background = new GameObject("background", typeof(RectTransform));
        RectTransform rectTrans = background.GetComponent<RectTransform>();
        rectTrans.parent = canvas2d.transform;
        rectTrans.anchoredPosition = new Vector2(0.5f, 0.5f);
        rectTrans.anchorMin = new Vector2(0f, 0f);
        rectTrans.anchorMax = new Vector2(1f, 1f);
        GraphicTest test = background.AddComponent<GraphicTest>();
        //		test.onDrag = (eventData) => {
        //			Debug.Log("onDrag..");
        //			if(mState == State2D.Idle){
        //				OnDrag(eventData.delta);
        //			}
        //		};

        test.color = new Color(0.95f, 0.95f, 0.95f, 1.0f);

        EventTrigger trigger = background.AddComponent<EventTrigger>();

        //OnClick;
        EventTrigger.Entry entry = new EventTrigger.Entry();
        trigger.triggers.Add(entry);
        entry.eventID = EventTriggerType.PointerClick;
        entry.callback.AddListener((eventData) => {
        //			PointerEventData data = eventData as PointerEventData;
        //			if(mState == State2D.Idle){
        //				//Debug.Log("onClick..");
        //				Vector2 wordPos = DrawHelper.PixelToReal(camera2d, data.position);
        //				Wall2D wall;
        //				if(segmentFill.Select(wordPos, out wall)){
        //					wall.Color = Color.green;
        //				}
        //			}
        });

        Wall2D selected = null;

        //OnPress Down;
        entry = new EventTrigger.Entry();
        trigger.triggers.Add(entry);
        entry.eventID = EventTriggerType.PointerDown;
        entry.callback.AddListener((eventData) => {
            PointerEventData data = eventData as PointerEventData;
            if(mState == State2D.Idle){
                Vector2 wordPos = DrawHelper.PixelToReal(camera2d, data.position);
                if(segmentFill.Select(wordPos, out selected)){
                    //Debug.Log(string.Format("change green..{0}, {1}", selected.StartPos, selected.EndPos ));
                    selected.Color = Color.green;

                    Wall2D wall = selected;

                }
            }

            if(mState == State2D.Draw){

            }
        });

        //OnPress Up;
        entry = new EventTrigger.Entry();
        trigger.triggers.Add(entry);
        entry.eventID = EventTriggerType.PointerUp;
        entry.callback.AddListener((eventData) => {
            PointerEventData data = eventData as PointerEventData;
            if(mState == State2D.Idle){
                if(selected != null){
                    selected.Color = Color.red;
                    selected = null;
                }
            }

        //			if(mState == State2D.Draw){
        //				ShowWallFill();
        //			}
        });

        //OnDrag;
        entry = new EventTrigger.Entry();
        trigger.triggers.Add(entry);
        entry.eventID = EventTriggerType.Drag;
        entry.callback.AddListener((eventData) => {
            //Debug.Log("onDrag..");
            PointerEventData data = eventData as PointerEventData;
            Vector2 realDelta = data.delta * DrawHelper.Scale;

            if(mState == State2D.Idle){
                if(selected == null){
                    //camera2d.transform.position = camera2d.transform.position + new Vector3(-realDelta.x, -realDelta.y, 0f);
                    DrawHelper.MoveRealRect(camera2d, realDelta);
                    MakeGrid2();
                }
                else{
                    Wall2D wall = selected;
                    Vector2 startT = wall.StartPos + realDelta;
                    Vector2 endT = wall.EndPos + realDelta;

                    List<Wall2D> joined = new List<Wall2D>();

                    if(wall.WallAtStart == null){
                        joined.Clear();
                        AddWallsJoined(joined, wall, true);
                        if(joined.Count > 0){
                            Vector3 target = joined[joined.Count-1].EndPos;
                            Vector2 delta = SnapPoint(startT, target);
                            startT = startT + delta;
                            endT = endT + delta;
                        }
                    }

                    if(wall.WallAtEnd == null){
                        joined.Clear();
                        AddWallsJoined(joined, wall, false);
                        if(joined.Count > 0){
                            Vector3 target = joined[joined.Count-1].StartPos;
                            //Debug.Log(string.Format("endT: ({0}, {1}), target: ({2}, {3})", endT.x, endT.y, target.x - endT.x, target.y - endT.y));
                            Vector2 delta = SnapPoint(endT, target);
                            startT = startT + delta;
                            endT = endT + delta;
                        }
                    }

                    if(wall.WallAtStart != null && wall.WallAtEnd != null){

                        Parallel.Line line = mParallel.GetOffsetLine(wall, realDelta);
                        Parallel.Line line1 = mParallel.GetLine(wall.WallAtStart.StartPos, wall.WallAtStart.EndPos);
                        Parallel.Line line2 = mParallel.GetLine(wall.WallAtEnd.StartPos, wall.WallAtEnd.EndPos);

                        Vector2 p = Vector2.zero;
                        if(mParallel.GetCrossPoint(line, line1, out p)){
                            if(wall.WallAtStart.StartPos != p){
                                wall.StartPos = p;
                                wall.WallAtStart.EndPos = p;
                            }
                            else{
                                Debug.Log("wallAtStart duplicate..");
                            }
                        }

                        if(mParallel.GetCrossPoint(line, line2, out p)){
                            if(wall.WallAtEnd.EndPos != p){
                                wall.EndPos = p;
                                wall.WallAtEnd.StartPos = p;
                            }
                            else{
                                Debug.Log("wallAtEnd duplicate..");
                            }
                        }

                        return;
                    }

                    wall.StartPos = startT;
                    if(wall.WallAtStart != null){
        //						wall.WallAtStart.WallAtEnd = null;
        //						wall.WallAtStart = null;

                        wall.WallAtStart.EndPos = startT;
                    }

                    wall.EndPos = endT;
                    if(wall.WallAtEnd != null){
        //						wall.WallAtEnd.WallAtStart = null;
        //						wall.WallAtEnd = null;

                        wall.WallAtEnd.StartPos = endT;
                    }
                }
            }
        });
    }
示例#4
0
    void Start()
    {
        camera2d = GameObject.Find ("Camera2d").GetComponent<Camera> ();
        VectorLine.SetCanvasCamera (camera2d);
        VectorLine.canvas3D.sortingLayerName = "World";

        gridLine = new VectorLine ("Grid", new Vector2[0], null, 1.0f);
        drawLine = new VectorLine("DrawLine", new Vector3[0], null, 1.0f, isContinue? LineType.Continuous : LineType.Discrete, isContinue ? Joins.None : Joins.None);
        //drawLine.rectTransform.gameObject.AddComponent<Outline>();
        rulerLine = new VectorLine("Ruler", new Vector3[0], null, 1.0f, LineType.Discrete);
        segmentOutline = new VectorLine("SegmentOutline", new Vector3[0], null, 1.0f, LineType.Discrete);
        segmentFill = new WallFill(VectorLine.canvas3D, "SegmentFill");

        Vector2[] room = RoomQuad.GetVertex();
        //DrawWall(room);
        List<Wall2D> roomWalls = DrawHelper.ContinueToDiscrete(room);
        Home.Get().AddWallList(roomWalls);

        //		VectorLine testLine = new VectorLine("test", new Vector3[] { Vector3.zero, new Vector3(1.0f, 0f, 0f), Vector3.one }, null, 2.0f, LineType.Continuous);
        //		testLine.color = Color.red;
        //		testLine.Draw3D();

        // Align 1-pixel lines on the pixel grid, so they don't potentially get messed up by anti-aliasing
        //gridLine.rectTransform.anchoredPosition = new Vector2 (.5f, .5f);
        gridLine.rectTransform.anchoredPosition = new Vector2(0f, 0f);
        //MakeGrid ();

        //SetScale(DrawHelper.unitPixels);
        DrawHelper.OnScaleChanged = MakeGrid2;
        DrawHelper.SetScale(camera2d, DrawHelper.unitPixels);

        mState = State2D.Idle;
    }
示例#5
0
    void Awake()
    {
        Canvas           canvas2d         = VectorLine.canvas;
        GraphicRaycaster graphicRaycaster = canvas2d.gameObject.AddComponent <GraphicRaycaster>();

        graphicRaycaster.blockingObjects = GraphicRaycaster.BlockingObjects.ThreeD;

        Button drawBtn = GameObject.Find("UIRoot/DrawBtn").GetComponent <Button>();

        bool clicked = false;

        drawBtn.onClick.AddListener(() => {
            clicked = !clicked;
            Debug.Log("On DrawBtn clicked.." + clicked);

            if (clicked)
            {
                if (this.mState != State2D.Draw)
                {
                    this.mState = State2D.Draw;
                }
            }
            else
            {
                if (this.mState == State2D.Draw)
                {
                    this.mState = State2D.Idle;
                }
            }
        });

        GameObject    background = new GameObject("background", typeof(RectTransform));
        RectTransform rectTrans  = background.GetComponent <RectTransform>();

        rectTrans.parent           = canvas2d.transform;
        rectTrans.anchoredPosition = new Vector2(0.5f, 0.5f);
        rectTrans.anchorMin        = new Vector2(0f, 0f);
        rectTrans.anchorMax        = new Vector2(1f, 1f);
        GraphicTest test = background.AddComponent <GraphicTest>();

//		test.onDrag = (eventData) => {
//			Debug.Log("onDrag..");
//			if(mState == State2D.Idle){
//				OnDrag(eventData.delta);
//			}
//		};

        test.color = new Color(0.95f, 0.95f, 0.95f, 1.0f);

        EventTrigger trigger = background.AddComponent <EventTrigger>();

        //OnClick;
        EventTrigger.Entry entry = new EventTrigger.Entry();
        trigger.triggers.Add(entry);
        entry.eventID = EventTriggerType.PointerClick;
        entry.callback.AddListener((eventData) => {
//			PointerEventData data = eventData as PointerEventData;
//			if(mState == State2D.Idle){
//				//Debug.Log("onClick..");
//				Vector2 wordPos = DrawHelper.PixelToReal(camera2d, data.position);
//				Wall2D wall;
//				if(segmentFill.Select(wordPos, out wall)){
//					wall.Color = Color.green;
//				}
//			}
        });

        Wall2D selected = null;

        //OnPress Down;
        entry = new EventTrigger.Entry();
        trigger.triggers.Add(entry);
        entry.eventID = EventTriggerType.PointerDown;
        entry.callback.AddListener((eventData) => {
            PointerEventData data = eventData as PointerEventData;
            if (mState == State2D.Idle)
            {
                Vector2 wordPos = DrawHelper.PixelToReal(camera2d, data.position);
                if (segmentFill.Select(wordPos, out selected))
                {
                    //Debug.Log(string.Format("change green..{0}, {1}", selected.StartPos, selected.EndPos ));
                    selected.Color = Color.green;

                    Wall2D wall = selected;
                }
            }
        });

        //OnPress Up;
        entry = new EventTrigger.Entry();
        trigger.triggers.Add(entry);
        entry.eventID = EventTriggerType.PointerUp;
        entry.callback.AddListener((eventData) => {
            PointerEventData data = eventData as PointerEventData;
            if (mState == State2D.Idle)
            {
                if (selected != null)
                {
                    selected.Color = Color.red;
                    selected       = null;
                }
            }
        });

        //OnDrag;
        entry = new EventTrigger.Entry();
        trigger.triggers.Add(entry);
        entry.eventID = EventTriggerType.Drag;
        entry.callback.AddListener((eventData) => {
            //Debug.Log("onDrag..");
            PointerEventData data = eventData as PointerEventData;
            Vector2 realDelta     = data.delta * DrawHelper.Scale;

            if (mState == State2D.Idle)
            {
                if (selected == null)
                {
                    //camera2d.transform.position = camera2d.transform.position + new Vector3(-realDelta.x, -realDelta.y, 0f);
                    DrawHelper.MoveRealRect(camera2d, realDelta);
                    MakeGrid2();
                }
                else
                {
                    Wall2D wall    = selected;
                    Vector2 startT = wall.StartPos + realDelta;
                    Vector2 endT   = wall.EndPos + realDelta;

                    List <Wall2D> joined = new List <Wall2D>();

                    if (wall.WallAtStart == null)
                    {
                        joined.Clear();
                        AddWallsJoined(joined, wall, true);
                        if (joined.Count > 0)
                        {
                            Vector3 target = joined[joined.Count - 1].EndPos;
                            Vector2 delta  = SnapPoint(startT, target);
                            startT         = startT + delta;
                            endT           = endT + delta;
                        }
                    }

                    if (wall.WallAtEnd == null)
                    {
                        joined.Clear();
                        AddWallsJoined(joined, wall, false);
                        if (joined.Count > 0)
                        {
                            Vector3 target = joined[joined.Count - 1].StartPos;
                            //Debug.Log(string.Format("endT: ({0}, {1}), target: ({2}, {3})", endT.x, endT.y, target.x - endT.x, target.y - endT.y));
                            Vector2 delta = SnapPoint(endT, target);
                            startT        = startT + delta;
                            endT          = endT + delta;
                        }
                    }

                    if (wall.WallAtStart != null && wall.WallAtEnd != null)
                    {
                        Parallel.Line line  = mParallel.GetOffsetLine(wall, realDelta);
                        Parallel.Line line1 = mParallel.GetLine(wall.WallAtStart.StartPos, wall.WallAtStart.EndPos);
                        Parallel.Line line2 = mParallel.GetLine(wall.WallAtEnd.StartPos, wall.WallAtEnd.EndPos);

                        Vector2 p = Vector2.zero;
                        if (mParallel.GetCrossPoint(line, line1, out p))
                        {
                            if (wall.WallAtStart.StartPos != p)
                            {
                                wall.StartPos           = p;
                                wall.WallAtStart.EndPos = p;
                            }
                            else
                            {
                                Debug.Log("wallAtStart duplicate..");
                            }
                        }

                        if (mParallel.GetCrossPoint(line, line2, out p))
                        {
                            if (wall.WallAtEnd.EndPos != p)
                            {
                                wall.EndPos             = p;
                                wall.WallAtEnd.StartPos = p;
                            }
                            else
                            {
                                Debug.Log("wallAtEnd duplicate..");
                            }
                        }

                        return;
                    }

                    wall.StartPos = startT;
                    if (wall.WallAtStart != null)
                    {
//						wall.WallAtStart.WallAtEnd = null;
//						wall.WallAtStart = null;

                        wall.WallAtStart.EndPos = startT;
                    }

                    wall.EndPos = endT;
                    if (wall.WallAtEnd != null)
                    {
//						wall.WallAtEnd.WallAtStart = null;
//						wall.WallAtEnd = null;

                        wall.WallAtEnd.StartPos = endT;
                    }
                }
            }
        });
    }