예제 #1
0
        public FerrTerrainBuilder(List<Polygon2D> polygons, Ferr2D_Path ferrPathPrototype, float cellWidth, float cellHeight)
        {
            this.polygons = polygons;
            this.ferrPathPrototype = ferrPathPrototype;

            this.cellWidth = cellWidth;
            this.cellHeight = cellHeight;
        }
예제 #2
0
        public FerrTerrainBuilder(List<Polygon2D> polygons, Ferr2D_Path ferrPathPrototype, Vector2 entranceCell, Vector2 exitCell, float cellWidth, float cellHeight, bool randomizeVertexColor = false)
        {
            this.polygons = polygons;
            this.ferrPathPrototype = ferrPathPrototype;

            this.cellWidth = cellWidth;
            this.cellHeight = cellHeight;

            this.entrancePoint.x = cellWidth * entranceCell.x;
            this.entrancePoint.y = cellHeight * entranceCell.y;

            this.exitPoint.x = cellWidth * exitCell.x;
            this.exitPoint.y = cellHeight * exitCell.y;

            this.randomizeVertexColor = randomizeVertexColor;
        }
예제 #3
0
    private void OnSceneGUI()
    {
        if (!Ferr2DT_PathTerrain.showGUI)
        {
            return;
        }

        Ferr2D_Path         path      = (Ferr2D_Path)target;
        Ferr2DT_PathTerrain terrain   = path.GetComponent <Ferr2DT_PathTerrain>();
        GUIStyle            iconStyle = new GUIStyle();

        iconStyle.alignment = TextAnchor.MiddleCenter;
        snap = new Vector3(EditorPrefs.GetFloat("MoveSnapX", 1), EditorPrefs.GetFloat("MoveSnapY", 1), EditorPrefs.GetFloat("MoveSnapZ", 1));

        // setup undoing things
        Undo.RecordObject(target, "Modified Path");

        if (Event.current.type == EventType.Repaint && terrain != null)
        {
            Ferr2DT_PathTerrainEditor.DrawColliderEdge(terrain);
        }

        // draw the path line
        if (Event.current.type == EventType.Repaint)
        {
            DoPath(path);
        }

        // Check for drag-selecting multiple points
        DragSelect(path);

        // do adding verts in when the shift key is down!
        if (Event.current.shift && !Event.current.control)
        {
            DoShiftAdd(path, iconStyle);
        }

        // draw and interact with all the path handles
        DoHandles(path, iconStyle);

        // if this was an undo, refresh stuff too
        if (Event.current.type == EventType.ValidateCommand)
        {
            switch (Event.current.commandName)
            {
            case "UndoRedoPerformed":
                // Only rebuild this from an undo if the inspector is not visible.
                UnityEngine.Object[] objs = Resources.FindObjectsOfTypeAll(Type.GetType("UnityEditor.InspectorWindow, UnityEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null", true));
                if (objs == null || objs.Length == 0)
                {
                    path.UpdateDependants(true);
                    if (OnChanged != null)
                    {
                        OnChanged();
                    }
                }
                break;
            }
        }

        // update everything that relies on this path, if the GUI changed
        if (GUI.changed)
        {
            if (PrefabUtility.GetCorrespondingObjectFromSource(target) != null)
            {
                NudgeArray(pathVerts);
                serializedObject.ApplyModifiedProperties();
            }

            UpdateDependentsSmart(path, false, false);
            EditorUtility.SetDirty(target);
            prevChanged = true;
        }
        else if (Event.current.type == EventType.Used)
        {
            if (prevChanged == true)
            {
                UpdateDependentsSmart(path, false, true);
            }
            prevChanged = false;
        }
    }
예제 #4
0
    private void DoNormalModeHandles(Ferr2D_Path path, Ferr2DT_PathTerrain terrain, int i, Matrix4x4 mat, Matrix4x4 invMat, Transform camTransform)
    {
        int     nextId     = i == path.Count - 1?(path.closed?0:i - 1):i + 1;
        Vector3 pos        = mat.MultiplyPoint3x4(path.pathVerts[i]);
        Vector3 posNext    = mat.MultiplyPoint3x4(path.pathVerts[nextId]);
        Vector3 normal     = -(Vector3)Ferr2D_Path.GetNormal(path.pathVerts, i, path.closed);
        bool    isSelected = false;

        if (selectedPoints != null)
        {
            isSelected = selectedPoints.Contains(i);
        }

        // check for moving the point
        CapFunction cap = CapDot;

        if (Event.current.control)
        {
            cap = isSelected ? (CapFunction)CapDotSelectedSnap : (CapFunction)CapDotSnap;
        }
        else
        {
            cap = isSelected ? (CapFunction)CapDotSelected     : (CapFunction)CapDot;
        }

        Vector3 result = Handles.FreeMoveHandle(pos, camTransform.rotation, HandleScale(pos) * Ferr2D_Visual.HandleSize, snap, cap);

        if (result != pos)
        {
            EnsureVertSelected(i, ref isSelected);

            Vector2 relative = GetRelativeMovementWithSnap(result, invMat, i, path);

            for (int s = 0; s < selectedPoints.Count; s++)
            {
                path.pathVerts[selectedPoints[s]] += relative;
            }
        }

        if (Ferr2DT_SceneOverlay.showIndices)
        {
            Vector3 labelPos = pos + normal;
            Handles.color = Ferr2D_Visual.IndicesColor;
            Handles.Label(labelPos, "" + i);
            Handles.color = Ferr2D_Visual.HandleColor;
        }

        if (!Ferr2DT_SceneOverlay.segmentLockMode)
        {
            float   scale      = HandleScale(pos) * Ferr2D_Visual.SmallHandleSize;
            Vector3 displayPos = pos;

            if (path.closed || i + 1 < path.pathVerts.Count)
            {
                displayPos = GetOverridePos(i, path, mat, pos, posNext);

                if (IsVisible(displayPos) && terrain.directionOverrides != null)
                {
                    cap = Event.current.alt ? (CapFunction)CapDotReset : GetDirIcon(terrain.directionOverrides[i]);
                    if (Handles.Button(displayPos, camTransform.rotation, scale, scale, cap))
                    {
                        EnsureVertSelected(i, ref isSelected);

                        Undo.RecordObject(terrain, "Override Vert Direction");

                        Ferr2DT_TerrainDirection dir = NextDir(terrain.directionOverrides[i]);
                        for (int s = 0; s < selectedPoints.Count; s++)
                        {
                            terrain.directionOverrides[selectedPoints[s]] = dir;
                        }
                        EditorUtility.SetDirty(terrain);
                        GUI.changed = true;
                    }
                }
            }

            displayPos = pos + normal * terrain.vertScales[i] * 2 * Ferr2DT_Menu.PathScale;
            if (IsVisible(displayPos))
            {
                cap = Event.current.alt ? (CapFunction)CapDotReset : (CapFunction)CapDotScale;

                Vector3 scaleMove = Handles.FreeMoveHandle(displayPos, camTransform.rotation, scale, Vector3.zero, cap);
                float   scaleAmt  = Vector3.Distance(displayPos, scaleMove);
                if (Mathf.Abs(scaleAmt) > 0.01f)
                {
                    EnsureVertSelected(i, ref isSelected);

                    Undo.RecordObject(terrain, "Scale Path Vert");

                    float vertScale = Vector3.Distance(scaleMove, pos) / 2 / Ferr2DT_Menu.PathScale;
                    vertScale = Mathf.Clamp(vertScale, 0.2f, 3f);
                    for (int s = 0; s < selectedPoints.Count; s++)
                    {
                        terrain.vertScales[selectedPoints[s]] = vertScale;
                    }
                    EditorUtility.SetDirty(terrain);
                    GUI.changed = true;
                }
            }

            // make sure we can add new point at the midpoints!
            if (i + 1 < path.pathVerts.Count || path.closed == true)
            {
                Vector3 mid         = (pos + posNext) / 2;
                float   handleScale = HandleScale(mid) * Ferr2D_Visual.HandleSize;

                if (Handles.Button(mid, camTransform.rotation, handleScale, handleScale, CapDotPlus))
                {
                    Vector2 pt = invMat.MultiplyPoint3x4(mid);

                    terrain.AddPoint(pt, nextId);
                    EditorUtility.SetDirty(terrain);
                    GUI.changed = true;
                }
            }
        }
    }
예제 #5
0
    private void DoHandles(Ferr2D_Path path, GUIStyle iconStyle)
    {
        Handles.color = new Color(1, 1, 1, 0);
        for (int i = 0; i < path.pathVerts.Count; i++)
        {
            Vector3 pos = path.transform.position + new Vector3(path.pathVerts[i].x, path.pathVerts[i].y, 0);

            // check if we want to remove points
            if (Event.current.control)
            {
                if (Handles.Button(pos + offset, Quaternion.identity, 0.6f, 0.6f, Handles.CircleCap))
                {
                    path.pathVerts.RemoveAt(i);
                    i--;
                    GUI.changed = true;
                }
                if (SetScale(pos + offset, texMinus, ref iconStyle)) Handles.Label(pos + offset, new GUIContent(texMinus), iconStyle);
            }
            else
            {
                // check for moving the point
                if (SetScale(pos + offset, texMinus, ref iconStyle)) Handles.Label(pos + offset, new GUIContent(texDot), iconStyle);
                Vector3 result = Handles.FreeMoveHandle(
                    pos + offset,
                    Quaternion.identity,
                    0.6f,
                    Vector3.zero, Handles.CircleCap);

                path.pathVerts[i] = new Vector2(
                    result.x - path.transform.position.x,
                    result.y - path.transform.position.y);

                // make sure we can add new point at the midpoints!
                if (i + 1 < path.pathVerts.Count || path.closed == true)
                {
                    int index = path.closed && i + 1 == path.pathVerts.Count ? 0 : i + 1;
                    Vector3 pos2 = path.transform.position + new Vector3(path.pathVerts[index].x, path.pathVerts[index].y, 0);
                    Vector3 mid = (pos + pos2) / 2;

                    if (Handles.Button(mid + offset, Quaternion.identity, 0.4f, 0.4f, Handles.CircleCap))
                    {
                        path.pathVerts.Insert(index, new Vector2(mid.x - path.transform.position.x, mid.y - path.transform.position.y));
                    }
                    if (SetScale(mid + offset, texDotPlus, ref iconStyle)) Handles.Label(mid + offset, new GUIContent(texDotPlus), iconStyle);
                }
            }
        }
    }
예제 #6
0
    private void DoHandles(Ferr2D_Path path, GUIStyle iconStyle)
    {
        Ferr2DT_PathTerrain terrain = path.gameObject.GetComponent <Ferr2DT_PathTerrain>();

        if (terrain)
        {
            terrain.MatchOverrides();
        }
        Quaternion inv = Quaternion.Inverse(path.transform.rotation);

        Handles.color = new Color(1, 1, 1, 0);
        for (int i = 0; i < path.pathVerts.Count; i++)
        {
            Vector3 pos        = path.transform.position + path.transform.rotation * Vector3.Scale(new Vector3(path.pathVerts[i].x, path.pathVerts[i].y, 0), path.transform.localScale);
            Vector3 posOff     = pos + offset;
            bool    isSelected = false;
            if (selectedPoints != null)
            {
                isSelected = selectedPoints.Contains(i);
            }

            // check if we want to remove points
            if (Event.current.alt)
            {
                float handleScale = HandleScale(posOff);
                if (IsVisible(posOff))
                {
                    SetScale(posOff, texMinus, ref iconStyle);
                    //Handles.Label(posOff, new GUIContent((isSelected || selectedPoints.Count <= 0) ? texMinusSelected : texMinus), iconStyle);
                }

                if (Handles.Button(posOff, SceneView.lastActiveSceneView.camera.transform.rotation, handleScale, handleScale, Handles.CircleCap))
                {
                    if (!isSelected && selectedPoints != null)
                    {
                        selectedPoints.Clear();
                        selectedPoints.Add(i);
                    }
                    if (selectedPoints != null)
                    {
                        for (int s = 0; s < selectedPoints.Count; s++)
                        {
                            if (terrain)
                            {
                                terrain.RemovePoint(selectedPoints[s]);
                            }
                            else
                            {
                                path.pathVerts.RemoveAt(selectedPoints[s]);
                            }
                            if (selectedPoints[s] <= i)
                            {
                                i--;
                            }

                            for (int u = 0; u < selectedPoints.Count; u++)
                            {
                                if (selectedPoints[u] > selectedPoints[s])
                                {
                                    selectedPoints[u] -= 1;
                                }
                            }
                        }
                    }
                    if (selectedPoints != null)
                    {
                        selectedPoints.Clear();
                    }
                    GUI.changed = true;
                }
                else if (Ferr2DT_SceneOverlay.editMode != Ferr2DT_EditMode.None)
                {
                    if (terrain && i + 1 < path.pathVerts.Count)
                    {
                        float   scale     = handleScale * 0.5f;
                        Vector3 dirOff    = GetTickerOffset(path, pos, i);
                        Vector3 posDirOff = posOff + dirOff;

                        if (IsVisible(posDirOff))
                        {
                            Texture2D icon = null;
                            if (Ferr2DT_SceneOverlay.editMode == Ferr2DT_EditMode.Override)
                            {
                                icon = GetDirIcon(terrain.directionOverrides[i]);
                            }
                            else if (Ferr2DT_SceneOverlay.editMode == Ferr2DT_EditMode.Scale)
                            {
                                icon = texScale;
                            }
                            if (Event.current.alt)
                            {
                                icon = texReset;
                            }

                            SetScale(posDirOff, icon, ref iconStyle, 0.5f);
                            Handles.Label(posDirOff, new GUIContent(icon), iconStyle);

                            if (Handles.Button(posDirOff, SceneView.lastActiveSceneView.camera.transform.rotation, scale, scale, Handles.CircleCap) && selectedPoints != null)
                            {
                                if (selectedPoints.Count < 2 || isSelected == false)
                                {
                                    selectedPoints.Clear();
                                    selectedPoints.Add(i);
                                    isSelected = true;
                                }

                                for (int s = 0; s < selectedPoints.Count; s++)
                                {
                                    if (Ferr2DT_SceneOverlay.editMode == Ferr2DT_EditMode.Override)
                                    {
                                        terrain.directionOverrides[selectedPoints[s]] = Ferr2DT_TerrainDirection.None;
                                    }
                                    else if (Ferr2DT_SceneOverlay.editMode == Ferr2DT_EditMode.Scale)
                                    {
                                        terrain.vertScales[selectedPoints[s]] = 1;
                                    }
                                }
                                GUI.changed = true;
                            }
                        }
                    }
                }
            }
            else
            {
                // check for moving the point
                Texture2D tex = null;
                if (Event.current.control)
                {
                    tex = isSelected ? texDotSelectedSnap : texDotSnap;
                }
                else
                {
                    tex = isSelected ? texDotSelected : texDot;
                }

                if (IsVisible(posOff))
                {
                    SetScale(posOff, texMinus, ref iconStyle);
                    Handles.Label(posOff, new GUIContent(tex), iconStyle);
                }
                Vector3 snap   = Event.current.control && Ferr_Menu.SnapMode == Ferr2DT_SnapMode.SnapRelative ? new Vector3(EditorPrefs.GetFloat("MoveSnapX"), EditorPrefs.GetFloat("MoveSnapY"), EditorPrefs.GetFloat("MoveSnapZ")) : Vector3.zero;
                Vector3 result = Handles.FreeMoveHandle(
                    posOff,
                    SceneView.lastActiveSceneView.camera.transform.rotation,
                    HandleScale(pos + offset),
                    snap,
                    Handles.CircleCap);

                if (result != posOff)
                {
                    if (selectedPoints != null)
                    {
                        if (selectedPoints.Count < 2 || isSelected == false)
                        {
                            selectedPoints.Clear();
                            selectedPoints.Add(i);
                            isSelected = true;
                        }
                    }

                    if (!(Event.current.control && Ferr_Menu.SnapMode == Ferr2DT_SnapMode.SnapRelative))
                    {
                        result = GetRealPoint(result, path.transform.position.z);
                    }
                    Vector3 global = (result - offset);
                    if (Event.current.control && Ferr_Menu.SnapMode == Ferr2DT_SnapMode.SnapGlobal)
                    {
                        global = SnapVector(global);
                    }
                    Vector3 local = inv * (global - path.transform.position);
                    if (Event.current.control && Ferr_Menu.SnapMode == Ferr2DT_SnapMode.SnapLocal)
                    {
                        local = SnapVector(local);
                    }
                    if (!Event.current.control && Ferr2DT_SceneOverlay.smartSnap && selectedPoints != null)
                    {
                        local = SmartSnap(local, path.pathVerts, selectedPoints, Ferr_Menu.SmartSnapDist);
                    }

                    Vector2 relative = new Vector2(
                        local.x / path.transform.localScale.x,
                        local.y / path.transform.localScale.y) - path.pathVerts[i];
                    if (selectedPoints != null)
                    {
                        for (int s = 0; s < selectedPoints.Count; s++)
                        {
                            path.pathVerts[selectedPoints[s]] += relative;
                        }
                    }
                }

                // if using terrain, check to see for any edge overrides
                if (Ferr2DT_SceneOverlay.showIndices)
                {
                    Vector3 labelPos = posOff + (Vector3)Ferr2D_Path.GetNormal(path.pathVerts, i, path.closed);
                    Handles.color = Color.white;
                    Handles.Label(labelPos, "" + i);
                    Handles.color = new Color(1, 1, 1, 0);
                }

                if (terrain)
                {// && i+1 < path.pathVerts.Count) {
                    float   scale     = HandleScale(pos + offset) * 0.5f;
                    Vector3 dirOff    = GetTickerOffset(path, pos, i);
                    Vector3 posDirOff = posOff + dirOff;

                    if (Ferr2DT_SceneOverlay.editMode == Ferr2DT_EditMode.Override && i + 1 < path.pathVerts.Count)
                    {
                        if (IsVisible(posDirOff))
                        {
                            SetScale(posDirOff, texMinus, ref iconStyle, 0.5f);
                            Handles.Label(posDirOff, new GUIContent(Event.current.alt ? texReset : GetDirIcon(terrain.directionOverrides[i])), iconStyle);

                            if (Handles.Button(posDirOff, SceneView.lastActiveSceneView.camera.transform.rotation, scale, scale, Handles.CircleCap) && selectedPoints != null)
                            {
                                if (selectedPoints.Count < 2 || isSelected == false)
                                {
                                    selectedPoints.Clear();
                                    selectedPoints.Add(i);
                                    isSelected = true;
                                }

                                Ferr2DT_TerrainDirection dir = NextDir(terrain.directionOverrides[i]);
                                for (int s = 0; s < selectedPoints.Count; s++)
                                {
                                    terrain.directionOverrides[selectedPoints[s]] = dir;
                                }
                                GUI.changed = true;
                            }
                        }
                    }
                    else if (Ferr2DT_SceneOverlay.editMode == Ferr2DT_EditMode.Scale)
                    {
                        if (IsVisible(posDirOff))
                        {
                            SetScale(posDirOff, texMinus, ref iconStyle, 0.5f);
                            Handles.Label(posDirOff, new GUIContent(Event.current.alt ? texReset : texScale), iconStyle);

                            Vector3 scaleMove = Handles.FreeMoveHandle(posDirOff, SceneView.lastActiveSceneView.camera.transform.rotation, scale, Vector3.zero, Handles.CircleCap);
                            float   scaleAmt  = scaleMove.y - posDirOff.y;
                            if (Mathf.Abs(scaleAmt) > 0.01f)
                            {
                                if (selectedPoints != null && selectedPoints.Count < 2 || isSelected == false)
                                {
                                    selectedPoints.Clear();
                                    selectedPoints.Add(i);
                                    isSelected = true;
                                }

                                float vertScale = terrain.vertScales[i] - Event.current.delta.y / 100f;
                                vertScale = Mathf.Clamp(vertScale, 0.2f, 3f);
                                if (selectedPoints != null)
                                {
                                    for (int s = 0; s < selectedPoints.Count; s++)
                                    {
                                        terrain.vertScales[selectedPoints[s]] = vertScale;
                                    }
                                }
                                GUI.changed = true;
                            }
                        }
                    }
                }

                // make sure we can add new point at the midpoints!
                if (i + 1 < path.pathVerts.Count || path.closed == true)
                {
                    int     index       = path.closed && i + 1 == path.pathVerts.Count ? 0 : i + 1;
                    Vector3 pos2        = path.transform.position + path.transform.rotation * Vector3.Scale(new Vector3(path.pathVerts[index].x, path.pathVerts[index].y, 0), path.transform.localScale);
                    Vector3 mid         = (pos + pos2) / 2;
                    float   handleScale = HandleScale(mid + offset);

                    if (Handles.Button(mid + offset, SceneView.lastActiveSceneView.camera.transform.rotation, handleScale, handleScale, Handles.CircleCap))
                    {
                        Vector2 pt = inv * new Vector2((mid.x - path.transform.position.x) / path.transform.localScale.x, (mid.y - path.transform.position.y) / path.transform.localScale.y);
                        if (terrain)
                        {
                            terrain.AddPoint(pt, index);
                        }
                        else
                        {
                            path.pathVerts.Insert(index, pt);
                        }
                    }
                    if (IsVisible(mid + offset))
                    {
                        SetScale(mid + offset, texDotPlus, ref iconStyle);
                        Handles.Label(mid + offset, new GUIContent(texDotPlus), iconStyle);
                    }
                }
            }
        }

        if (selectedPoints != null && Event.current.type == EventType.keyDown && Event.current.keyCode == KeyCode.Delete && selectedPoints.Count > 0)
        {
            for (int s = 0; s < selectedPoints.Count; s++)
            {
                if (terrain)
                {
                    terrain.RemovePoint(selectedPoints[s]);
                }
                else
                {
                    path.pathVerts.RemoveAt(selectedPoints[s]);
                }

                for (int u = 0; u < selectedPoints.Count; u++)
                {
                    if (selectedPoints[u] > selectedPoints[s])
                    {
                        selectedPoints[u] -= 1;
                    }
                }
            }
            selectedPoints.Clear();
            GUI.changed = true;
            Event.current.Use();
        }
    }
예제 #7
0
	private void    UpdateDependentsSmart(Ferr2D_Path aPath, bool aForce, bool aFullUpdate) {
		if (aForce || Ferr2DT_Menu.UpdateTerrainSkipFrames == 0 || updateCount % Ferr2DT_Menu.UpdateTerrainSkipFrames == 0) {
			aPath.UpdateDependants(aFullUpdate);
			if (Application.isPlaying) aPath.UpdateColliders();
			if (OnChanged != null) OnChanged();
		}
		updateCount += 1;
	}
예제 #8
0
	private void    DoShiftAdd           (Ferr2D_Path path, GUIStyle iconStyle)
	{
        Vector3             snap      = Event.current.control ? new Vector3(EditorPrefs.GetFloat("MoveSnapX"), EditorPrefs.GetFloat("MoveSnapY"), EditorPrefs.GetFloat("MoveSnapZ")) : Vector3.zero;
		Ferr2DT_PathTerrain terrain   = path.gameObject.GetComponent<Ferr2DT_PathTerrain>();
        Transform           transform = path.transform;
        Transform           camTransform = SceneView.lastActiveSceneView.camera.transform;
		Vector3             pos       = transform.InverseTransformPoint( GetMousePos(Event.current.mousePosition, transform) );
		bool                hasDummy  = path.pathVerts.Count <= 0;
		
		if (hasDummy) path.pathVerts.Add(Vector2.zero);
		
		int   closestID  = path.GetClosestSeg(pos);
		int   secondID   = closestID + 1 >= path.Count ? 0 : closestID + 1;
		
		float firstDist  = Vector2.Distance(pos, path.pathVerts[closestID]);
		float secondDist = Vector2.Distance(pos, path.pathVerts[secondID]);
		
		Vector3 local  = pos;
		if (Event.current.control && Ferr2DT_Menu.SnapMode == Ferr2DT_Menu.SnapType.SnapLocal ) local  = SnapVector(local,  snap);
		Vector3 global = transform.TransformPoint(pos);
		if (Event.current.control && Ferr2DT_Menu.SnapMode == Ferr2DT_Menu.SnapType.SnapGlobal) global = SnapVector(global, snap);
		
		Handles.color = Color.white;
		if (!(secondID == 0 && !path.closed && firstDist > secondDist))
		{
			Handles.DrawLine( global, transform.TransformPoint(path.pathVerts[closestID]));
		}
		if (!(secondID == 0 && !path.closed && firstDist < secondDist))
		{
			Handles.DrawLine( global, transform.TransformPoint(path.pathVerts[secondID]));
		}
		Handles.color = new Color(1, 1, 1, 1);
		
		Vector3 handlePos = transform.TransformPoint(pos);
        float   scale     = HandleScale(handlePos);
		if (Handles.Button(handlePos, camTransform.rotation, scale, scale, CapDotPlus))
		{
			Vector3 finalPos = transform.InverseTransformPoint(global);
			if (secondID == 0) {
				if (firstDist < secondDist) {
					if (terrain)
						terrain.AddPoint(finalPos);
					else
						path.pathVerts.Add(finalPos);
				} else {
					if (terrain)
						terrain.AddPoint(finalPos, 0);
					else
						path.pathVerts.Insert(0, finalPos);
				}
			} else {
				if (terrain)
					terrain.AddPoint(finalPos, Mathf.Max(closestID, secondID));
				else
					path.pathVerts.Insert(Mathf.Max(closestID, secondID), finalPos);
			}
			selectedPoints.Clear();
			GUI.changed = true;
		}
		
		if (hasDummy) path.pathVerts.RemoveAt(0);
	}
예제 #9
0
 private void DoPath    (Ferr2D_Path path)
 {
     Handles.color = Color.white;
     Ferr2DT_PathTerrain terrain = path.gameObject.GetComponent<Ferr2DT_PathTerrain>();
     List<Vector2> verts = terrain == null ? path.GetVertsRaw() : path.GetVerts(false, 2, terrain.splitCorners);
     for (int i = 0; i < verts.Count - 1; i++)
     {
         Vector3 pos  = path.transform.position + path.transform.rotation * Vector3.Scale(new Vector3(verts[i    ].x, verts[i    ].y, 0), path.transform.localScale);
         Vector3 pos2 = path.transform.position + path.transform.rotation * Vector3.Scale(new Vector3(verts[i + 1].x, verts[i + 1].y, 0), path.transform.localScale);
         Handles.DrawLine(pos + offset, pos2 + offset);
     }
     if (path.closed)
     {
         Vector3 pos  = path.transform.position + path.transform.rotation * Vector3.Scale(new Vector3(verts[0              ].x, verts[0              ].y, 0), path.transform.localScale);
         Vector3 pos2 = path.transform.position + path.transform.rotation * Vector3.Scale(new Vector3(verts[verts.Count - 1].x, verts[verts.Count - 1].y, 0), path.transform.localScale);
         Handles.DrawLine(pos + offset, pos2 + offset);
     }
 }
    private void    DoHandles(Ferr2D_Path path, GUIStyle iconStyle)
    {
        Vector3             snap         = Event.current.control ? new Vector3(EditorPrefs.GetFloat("MoveSnapX"), EditorPrefs.GetFloat("MoveSnapY"), EditorPrefs.GetFloat("MoveSnapZ")) : Vector3.zero;
        Transform           transform    = path.transform;
        Matrix4x4           mat          = transform.localToWorldMatrix;
        Matrix4x4           invMat       = transform.worldToLocalMatrix;
        Transform           camTransform = SceneView.lastActiveSceneView.camera.transform;
        Ferr2DT_PathTerrain terrain      = path.GetComponent <Ferr2DT_PathTerrain>();

        if (terrain)
        {
            terrain.MatchOverrides();
        }

        Handles.color = new Color(1, 1, 1, 1);
        for (int i = 0; i < path.pathVerts.Count; i++)
        {
            Vector3 pos        = mat.MultiplyPoint3x4(path.pathVerts[i]);
            Vector3 posStart   = pos;
            bool    isSelected = false;
            if (selectedPoints != null)
            {
                isSelected = selectedPoints.Contains(i);
            }

            // check if we want to remove points
            if (Event.current.alt)
            {
                float handleScale           = HandleScale(posStart);
                Handles.DrawCapFunction cap = (isSelected || selectedPoints.Count <= 0) ? (Handles.DrawCapFunction)CapDotMinusSelected : (Handles.DrawCapFunction)CapDotMinus;
                if (Handles.Button(posStart, camTransform.rotation, handleScale, handleScale, cap))
                {
                    if (!isSelected)
                    {
                        selectedPoints.Clear();
                        selectedPoints.Add(i);
                    }
                    for (int s = 0; s < selectedPoints.Count; s++)
                    {
                        if (terrain)
                        {
                            terrain.RemovePoint(selectedPoints[s]);
                        }
                        else
                        {
                            path.pathVerts.RemoveAt(selectedPoints[s]);
                        }
                        if (selectedPoints[s] <= i)
                        {
                            i--;
                        }

                        for (int u = 0; u < selectedPoints.Count; u++)
                        {
                            if (selectedPoints[u] > selectedPoints[s])
                            {
                                selectedPoints[u] -= 1;
                            }
                        }
                    }
                    selectedPoints.Clear();
                    GUI.changed = true;
                }
                else if (Ferr2DT_SceneOverlay.editMode != Ferr2DT_EditMode.None)
                {
                    if (terrain && i + 1 < path.pathVerts.Count)
                    {
                        float   scale     = handleScale * 0.5f;
                        Vector3 dirOff    = GetTickerOffset(path, pos, i);
                        Vector3 posDirOff = posStart + dirOff;

                        if (IsVisible(posDirOff))
                        {
                            cap = null;
                            if (Ferr2DT_SceneOverlay.editMode == Ferr2DT_EditMode.Override)
                            {
                                cap = GetDirIcon(terrain.directionOverrides[i]);
                            }
                            else if (Ferr2DT_SceneOverlay.editMode == Ferr2DT_EditMode.Scale)
                            {
                                cap = CapDotScale;
                            }
                            if (Event.current.alt)
                            {
                                cap = CapDotReset;
                            }

                            if (Handles.Button(posDirOff, camTransform.rotation, scale, scale, cap))
                            {
                                if (selectedPoints.Count < 2 || isSelected == false)
                                {
                                    selectedPoints.Clear();
                                    selectedPoints.Add(i);
                                    isSelected = true;
                                }

                                for (int s = 0; s < selectedPoints.Count; s++)
                                {
                                    if (Ferr2DT_SceneOverlay.editMode == Ferr2DT_EditMode.Override)
                                    {
                                        terrain.directionOverrides[selectedPoints[s]] = Ferr2DT_TerrainDirection.None;
                                    }
                                    else if (Ferr2DT_SceneOverlay.editMode == Ferr2DT_EditMode.Scale)
                                    {
                                        terrain.vertScales        [selectedPoints[s]] = 1;
                                    }
                                }
                                GUI.changed = true;
                            }
                        }
                    }
                }
            }
            else
            {
                // check for moving the point
                Handles.DrawCapFunction cap = CapDot;
                if (Event.current.control)
                {
                    cap = isSelected ? (Handles.DrawCapFunction)CapDotSelectedSnap : (Handles.DrawCapFunction)CapDotSnap;
                }
                else
                {
                    cap = isSelected ? (Handles.DrawCapFunction)CapDotSelected     : (Handles.DrawCapFunction)CapDot;
                }

                Vector3 result = Handles.FreeMoveHandle(
                    posStart,
                    camTransform.rotation,
                    HandleScale(pos),
                    snap,
                    cap);

                if (result != posStart)
                {
                    if (selectedPoints.Count < 2 || isSelected == false)
                    {
                        selectedPoints.Clear();
                        selectedPoints.Add(i);
                        isSelected = true;
                    }

                    if (!(Event.current.control && Ferr2DT_Menu.SnapMode == Ferr2DT_Menu.SnapType.SnapRelative))
                    {
                        result = GetRealPoint(result, transform);
                    }

                    Vector3 global = result;
                    if (Event.current.control && Ferr2DT_Menu.SnapMode == Ferr2DT_Menu.SnapType.SnapGlobal)
                    {
                        global = SnapVector(global, snap);
                    }
                    Vector3 local = invMat.MultiplyPoint3x4(global);
                    if (Event.current.control && Ferr2DT_Menu.SnapMode == Ferr2DT_Menu.SnapType.SnapLocal)
                    {
                        local = SnapVector(local, snap);
                    }
                    if (!Event.current.control && Ferr2DT_SceneOverlay.smartSnap)
                    {
                        local = SmartSnap(local, path.pathVerts, selectedPoints, Ferr2DT_Menu.SmartSnapDist);
                    }

                    Vector2 relative = new Vector2(local.x, local.y) - path.pathVerts[i];

                    for (int s = 0; s < selectedPoints.Count; s++)
                    {
                        path.pathVerts[selectedPoints[s]] += relative;
                    }
                }

                // if using terrain, check to see for any edge overrides
                if (Ferr2DT_SceneOverlay.showIndices)
                {
                    Vector3 labelPos = posStart + (Vector3)Ferr2D_Path.GetNormal(path.pathVerts, i, path.closed);
                    Handles.color = Color.white;
                    Handles.Label(labelPos, "" + i);
                    Handles.color = new Color(1, 1, 1, 0);
                }

                if (terrain)
                {
                    float   scale     = HandleScale(pos) * 0.5f;
                    Vector3 dirOff    = GetTickerOffset(path, pos, i);
                    Vector3 posDirOff = posStart + dirOff;

                    if (Ferr2DT_SceneOverlay.editMode == Ferr2DT_EditMode.Override && i + 1 < path.pathVerts.Count)
                    {
                        if (IsVisible(posDirOff) && terrain.directionOverrides != null)
                        {
                            cap = Event.current.alt ? (Handles.DrawCapFunction)CapDotReset : GetDirIcon(terrain.directionOverrides[i]);
                            if (Handles.Button(posDirOff, camTransform.rotation, scale, scale, cap))
                            {
                                if (selectedPoints.Count < 2 || isSelected == false)
                                {
                                    selectedPoints.Clear();
                                    selectedPoints.Add(i);
                                    isSelected = true;
                                }

                                Ferr2DT_TerrainDirection dir = NextDir(terrain.directionOverrides[i]);
                                for (int s = 0; s < selectedPoints.Count; s++)
                                {
                                    terrain.directionOverrides[selectedPoints[s]] = dir;
                                }
                                GUI.changed = true;
                            }
                        }
                    }
                    else if (Ferr2DT_SceneOverlay.editMode == Ferr2DT_EditMode.Scale)
                    {
                        if (IsVisible(posDirOff))
                        {
                            cap = Event.current.alt ? (Handles.DrawCapFunction)CapDotReset : (Handles.DrawCapFunction)CapDotScale;

                            Vector3 scaleMove = Handles.FreeMoveHandle(posDirOff, camTransform.rotation, scale, Vector3.zero, cap);
                            float   scaleAmt  = scaleMove.y - posDirOff.y;
                            if (Mathf.Abs(scaleAmt) > 0.01f)
                            {
                                if (selectedPoints.Count < 2 || isSelected == false)
                                {
                                    selectedPoints.Clear();
                                    selectedPoints.Add(i);
                                    isSelected = true;
                                }

                                float vertScale = terrain.vertScales[i] - Event.current.delta.y / 100f;
                                vertScale = Mathf.Clamp(vertScale, 0.2f, 3f);
                                for (int s = 0; s < selectedPoints.Count; s++)
                                {
                                    terrain.vertScales[selectedPoints[s]] = vertScale;
                                }
                                GUI.changed = true;
                            }
                        }
                    }
                }

                // make sure we can add new point at the midpoints!
                if (i + 1 < path.pathVerts.Count || path.closed == true)
                {
                    int     index       = path.closed && i + 1 == path.pathVerts.Count ? 0 : i + 1;
                    Vector3 pos2        = mat.MultiplyPoint3x4(path.pathVerts[index]);
                    Vector3 mid         = (pos + pos2) / 2;
                    float   handleScale = HandleScale(mid);

                    if (Handles.Button(mid, camTransform.rotation, handleScale, handleScale, CapDotPlus))
                    {
                        Vector2 pt = invMat.MultiplyPoint3x4(mid);
                        if (terrain)
                        {
                            terrain.AddPoint(pt, index);
                        }
                        else
                        {
                            path.pathVerts.Insert(index, pt);
                        }
                    }
                }
            }
        }

        if (Event.current.type == EventType.KeyDown && Event.current.keyCode == KeyCode.Delete && selectedPoints.Count > 0)
        {
            for (int s = 0; s < selectedPoints.Count; s++)
            {
                if (terrain)
                {
                    terrain.RemovePoint(selectedPoints[s]);
                }
                else
                {
                    path.pathVerts.RemoveAt(selectedPoints[s]);
                }

                for (int u = 0; u < selectedPoints.Count; u++)
                {
                    if (selectedPoints[u] > selectedPoints[s])
                    {
                        selectedPoints[u] -= 1;
                    }
                }
            }
            selectedPoints.Clear();
            GUI.changed = true;
            Event.current.Use();
        }
    }
예제 #11
0
    private void DoHandles(Ferr2D_Path path, GUIStyle iconStyle)
    {
#if FERR2D_TERRAIN
        Ferr2DT_PathTerrain terrain = path.gameObject.GetComponent <Ferr2DT_PathTerrain>();
        if (terrain)
        {
            terrain.MatchOverrides();
        }
#endif

        Handles.color = new Color(1, 1, 1, 0);
        for (int i = 0; i < path.pathVerts.Count; i++)
        {
            Vector3 pos = path.transform.position + Vector3.Scale(new Vector3(path.pathVerts[i].x, path.pathVerts[i].y, 0), path.transform.localScale);

            // check if we want to remove points
            if (Event.current.control)
            {
                if (Handles.Button(pos + offset, Quaternion.identity, HandleScale(pos + offset), HandleScale(pos + offset), Handles.CircleCap))
                {
                    path.pathVerts.RemoveAt(i);
#if FERR2D_TERRAIN
                    if (terrain)
                    {
                        terrain.directionOverrides.RemoveAt(i);
                    }
#endif
                    i--;
                    GUI.changed = true;
                }
                if (SetScale(pos + offset, texMinus, ref iconStyle))
                {
                    Handles.Label(pos + offset, new GUIContent(texMinus), iconStyle);
                }
            }
            else
            {
                // check for moving the point
                if (SetScale(pos + offset, texMinus, ref iconStyle))
                {
                    Handles.Label(pos + offset, new GUIContent(texDot), iconStyle);
                }
                Vector3 result = Handles.FreeMoveHandle(
                    pos + offset,
                    Quaternion.identity,
                    HandleScale(pos + offset),
                    Vector3.zero, Handles.CircleCap);

                path.pathVerts[i] = new Vector2(
                    (result.x - path.transform.position.x) / path.transform.localScale.x,
                    (result.y - path.transform.position.y) / path.transform.localScale.y);

                // if using terrain, check to see for any edge overrides
#if FERR2D_TERRAIN
                if (terrain && i + 1 < path.pathVerts.Count)
                {
                    float   scale  = HandleScale(pos + offset) * 0.5f;
                    Vector3 dirOff = Vector3.zero;
                    if (i + 1 < path.pathVerts.Count || path.closed == true)
                    {
                        int     index = path.closed && i + 1 == path.pathVerts.Count ? 0 : i + 1;
                        Vector3 delta = path.pathVerts[index] - path.pathVerts[i];
                        delta.Normalize();
                        Vector3 norm = new Vector3(-delta.y, delta.x, 0);
                        dirOff = delta * scale * 3 + new Vector3(norm.x, norm.y, 0) * scale * 2;
                    }

                    if (SetScale(pos + offset + dirOff, texMinus, ref iconStyle, 0.5f))
                    {
                        Handles.Label(pos + offset + dirOff, new GUIContent(GetDirIcon(terrain.directionOverrides[i])), iconStyle);
                    }
                    if (Handles.Button(pos + offset + dirOff, Quaternion.identity, scale, scale, Handles.CircleCap))
                    {
                        terrain.directionOverrides[i] = NextDir(terrain.directionOverrides[i]);
                        GUI.changed = true;
                    }
                }
#endif

                // make sure we can add new point at the midpoints!
                if (i + 1 < path.pathVerts.Count || path.closed == true)
                {
                    int     index = path.closed && i + 1 == path.pathVerts.Count ? 0 : i + 1;
                    Vector3 pos2  = path.transform.position + Vector3.Scale(new Vector3(path.pathVerts[index].x, path.pathVerts[index].y, 0), path.transform.localScale);
                    Vector3 mid   = (pos + pos2) / 2;

                    if (Handles.Button(mid + offset, Quaternion.identity, HandleScale(mid + offset), HandleScale(mid + offset), Handles.CircleCap))
                    {
                        path.pathVerts.Insert(index, new Vector2((mid.x - path.transform.position.x) / path.transform.localScale.x, (mid.y - path.transform.position.y) / path.transform.localScale.y));
#if FERR2D_TERRAIN
                        if (terrain)
                        {
                            terrain.directionOverrides.Insert(index, Ferr2DT_TerrainDirection.None);
                        }
#endif
                    }
                    if (SetScale(mid + offset, texDotPlus, ref iconStyle))
                    {
                        Handles.Label(mid + offset, new GUIContent(texDotPlus), iconStyle);
                    }
                }
            }
        }
    }
예제 #12
0
    private void DoShiftAdd(Ferr2D_Path path, GUIStyle iconStyle)
    {
#if FERR2D_TERRAIN
        Ferr2DT_PathTerrain terrain  = path.gameObject.GetComponent<Ferr2DT_PathTerrain>();
#endif
        Quaternion          inv      = Quaternion.Inverse(path.transform.rotation);
        Vector2             pos      = GetMousePos(Event.current.mousePosition, path.transform.position.z) - new Vector2(path.transform.position.x, path.transform.position.y);
        bool                hasDummy = path.pathVerts.Count <= 0;

        if (hasDummy) path.pathVerts.Add(Vector2.zero);

        int   closestID  = path.GetClosestSeg(inv * new Vector2(pos.x / path.transform.localScale.x, pos.y / path.transform.localScale.y));
        int   secondID   = closestID + 1 >= path.Count ? 0 : closestID + 1;

        float firstDist  = Vector2.Distance(pos, path.pathVerts[closestID]);
        float secondDist = Vector2.Distance(pos, path.pathVerts[secondID]);

        Vector3 local  = pos;
        if (Ferr_Menu.SnapMode == Ferr2DT_SnapMode.Local ) local  = SnapVector(local );
        Vector3 global = path.transform.position + local;
        if (Ferr_Menu.SnapMode == Ferr2DT_SnapMode.Global) global = SnapVector(global);

        Handles.color = Color.white;
        if (!(secondID == 0 && !path.closed && firstDist > secondDist))
        {
            Handles.DrawLine(
                global,
                path.transform.position + path.transform.rotation * Vector3.Scale(new Vector3(path.pathVerts[closestID].x, path.pathVerts[closestID].y, 0), path.transform.localScale));
        }
        if (!(secondID == 0 && !path.closed && firstDist < secondDist))
        {
            Handles.DrawLine(
                global,
                path.transform.position + path.transform.rotation * Vector3.Scale(new Vector3(path.pathVerts[secondID].x, path.pathVerts[secondID].y, 0), path.transform.localScale));
        }
        Handles.color = new Color(1, 1, 1, 0);

        Vector3 handlePos = new Vector3(pos.x, pos.y, 0) + path.transform.position + offset;
        if (Handles.Button(handlePos, Quaternion.identity, HandleScale(handlePos), HandleScale(handlePos), Handles.CircleCap))
        {
            Vector3    finalPos = inv * (new Vector3(global.x / path.transform.localScale.x, global.y / path.transform.localScale.y, 0) - path.transform.position);
            if (secondID == 0)
            {
                if (firstDist < secondDist)
                {
                    path.pathVerts.Add(finalPos);
#if FERR2D_TERRAIN
                    if (terrain)
                        terrain.directionOverrides.Add(Ferr2DT_TerrainDirection.None);
#endif
                }
                else
                {
                    path.pathVerts.Insert(0, finalPos);
#if FERR2D_TERRAIN
                    if (terrain)
                        terrain.directionOverrides.Insert(0, Ferr2DT_TerrainDirection.None);
#endif
                }
            }
            else
            {
                path.pathVerts.Insert(Mathf.Max(closestID, secondID), finalPos);
#if FERR2D_TERRAIN
                if (terrain)
                    terrain.directionOverrides.Insert(Mathf.Max(closestID, secondID), Ferr2DT_TerrainDirection.None);
#endif
            }
            GUI.changed = true;
        }
        if (SetScale(new Vector3(pos.x, pos.y, 0) + path.transform.position + offset, texDotPlus, ref iconStyle)) Handles.Label(new Vector3(pos.x, pos.y, 0) + path.transform.position + offset, new GUIContent(texDotPlus), iconStyle);

        if (hasDummy) path.pathVerts.RemoveAt(0);
    }
예제 #13
0
    private void DoShiftAdd(Ferr2D_Path path, GUIStyle iconStyle)
    {
#if FERR2D_TERRAIN
        Ferr2DT_PathTerrain terrain = path.gameObject.GetComponent <Ferr2DT_PathTerrain>();
#endif

        Vector2 pos = GetMousePos(Event.current.mousePosition, path.transform.position.z) - new Vector2(path.transform.position.x, path.transform.position.y);

        int closestID = path.GetClosestSeg(new Vector2(pos.x / path.transform.localScale.x, pos.y / path.transform.localScale.y));
        int secondID  = closestID + 1 >= path.Count ? 0 : closestID + 1;

        float firstDist  = Vector2.Distance(pos, path.pathVerts[closestID]);
        float secondDist = Vector2.Distance(pos, path.pathVerts[secondID]);

        Handles.color = Color.white;
        if (!(secondID == 0 && !path.closed && firstDist > secondDist))
        {
            Handles.DrawLine(
                path.transform.position + new Vector3(pos.x, pos.y, 0),
                path.transform.position + Vector3.Scale(new Vector3(path.pathVerts[closestID].x, path.pathVerts[closestID].y, 0), path.transform.localScale));
        }
        if (!(secondID == 0 && !path.closed && firstDist < secondDist))
        {
            Handles.DrawLine(
                path.transform.position + new Vector3(pos.x, pos.y, 0),
                path.transform.position + Vector3.Scale(new Vector3(path.pathVerts[secondID].x, path.pathVerts[secondID].y, 0), path.transform.localScale));
        }
        Handles.color = new Color(1, 1, 1, 0);

        Vector3 handlePos = new Vector3(pos.x, pos.y, 0) + path.transform.position + offset;
        if (Handles.Button(handlePos, Quaternion.identity, HandleScale(handlePos), HandleScale(handlePos), Handles.CircleCap))
        {
            if (secondID == 0)
            {
                if (firstDist < secondDist)
                {
                    path.pathVerts.Add(new Vector2(pos.x / path.transform.localScale.x, pos.y / path.transform.localScale.y));
#if FERR2D_TERRAIN
                    if (terrain)
                    {
                        terrain.directionOverrides.Add(Ferr2DT_TerrainDirection.None);
                    }
#endif
                }
                else
                {
                    path.pathVerts.Insert(0, new Vector2(pos.x / path.transform.localScale.x, pos.y / path.transform.localScale.y));
#if FERR2D_TERRAIN
                    if (terrain)
                    {
                        terrain.directionOverrides.Insert(0, Ferr2DT_TerrainDirection.None);
                    }
#endif
                }
            }
            else
            {
                path.pathVerts.Insert(Mathf.Max(closestID, secondID), new Vector2(pos.x / path.transform.localScale.x, pos.y / path.transform.localScale.y));
#if FERR2D_TERRAIN
                if (terrain)
                {
                    terrain.directionOverrides.Insert(Mathf.Max(closestID, secondID), Ferr2DT_TerrainDirection.None);
                }
#endif
            }
            GUI.changed = true;
        }
        if (SetScale(new Vector3(pos.x, pos.y, 0) + path.transform.position + offset, texDotPlus, ref iconStyle))
        {
            Handles.Label(new Vector3(pos.x, pos.y, 0) + path.transform.position + offset, new GUIContent(texDotPlus), iconStyle);
        }
    }
예제 #14
0
    private void AddEdge()
    {
        // split the path into segments based on the split angle
        List <List <int>               > segments = new List <List <int>               >();
        List <Ferr2DT_TerrainDirection>  dirs     = new List <Ferr2DT_TerrainDirection>();
        List <int> order = new List <int>();

        segments = GetSegments(Path.GetVertsRaw(), out dirs);
        if (dirs.Count < segments.Count)
        {
            dirs.Add(directionOverrides[directionOverrides.Count - 1]);
        }
        for (int i = 0; i < segments.Count; i++)
        {
            order.Add(i);
        }

        order.Sort(
            new Ferr_LambdaComparer <int>(
                (x, y) => {
            Ferr2DT_TerrainDirection dirx = dirs[x] == Ferr2DT_TerrainDirection.None ? Ferr2D_Path.GetDirection(Path.pathVerts, segments[x], 0, fill == Ferr2DT_FillMode.InvertedClosed) : dirs[x];
            Ferr2DT_TerrainDirection diry = dirs[y] == Ferr2DT_TerrainDirection.None ? Ferr2D_Path.GetDirection(Path.pathVerts, segments[y], 0, fill == Ferr2DT_FillMode.InvertedClosed) : dirs[y];
            return(terrainMaterial.GetDescriptor(diry).zOffset.CompareTo(terrainMaterial.GetDescriptor(dirx).zOffset));
        }
                ));

        // process the segments into meshes
        for (int i = 0; i < order.Count; i++)
        {
            AddSegment(Ferr2D_Path.IndicesToPath(Path.pathVerts, segments[order[i]]), GetScalesFromIndices(segments[order[i]]), order.Count <= 1 && Path.closed, smoothPath, dirs[order[i]]);
        }
    }
예제 #15
0
    private void DoShiftAdd(Ferr2D_Path path, GUIStyle iconStyle)
    {
        Vector2 pos = GetMousePos(Event.current.mousePosition, path.transform.position.z) - new Vector2(path.transform.position.x, path.transform.position.y);

        int closestID = path.GetClosestSeg(pos);
        int secondID  = closestID + 1 >= path.Count ? 0 : closestID + 1;

        float firstDist  = Vector2.Distance(pos, path.pathVerts[closestID]);
        float secondDist = Vector2.Distance(pos, path.pathVerts[secondID]);

        Handles.color = Color.white;
        if (!(secondID == 0 && !path.closed && firstDist > secondDist))
        {
            Handles.DrawLine(
                path.transform.position + new Vector3(pos.x, pos.y, 0),
                path.transform.position + new Vector3(path.pathVerts[closestID].x, path.pathVerts[closestID].y, 0));
        }
        if (!(secondID == 0 && !path.closed && firstDist < secondDist))
        {
            Handles.DrawLine(
                path.transform.position + new Vector3(pos.x, pos.y, 0),
                path.transform.position + new Vector3(path.pathVerts[secondID].x, path.pathVerts[secondID].y, 0));
        }
        Handles.color = new Color(1, 1, 1, 0);

        if (Handles.Button(new Vector3(pos.x, pos.y, 0) + path.transform.position + offset, Quaternion.identity, 0.4f, 0.4f, Handles.CircleCap))
        {
            if (secondID == 0)
            {
                if (firstDist < secondDist)
                {
                    path.pathVerts.Add(new Vector2(pos.x, pos.y));
                }
                else
                {
                    path.pathVerts.Insert(0, new Vector2(pos.x, pos.y));
                }
            }
            else
            {
                path.pathVerts.Insert(Mathf.Max(closestID, secondID), new Vector2(pos.x, pos.y));
            }
            GUI.changed = true;
        }
        if (SetScale(new Vector3(pos.x, pos.y, 0) + path.transform.position + offset, texDotPlus, ref iconStyle)) Handles.Label(new Vector3(pos.x, pos.y, 0) + path.transform.position + offset, new GUIContent(texDotPlus), iconStyle);
    }
예제 #16
0
    private Vector3 GetRelativeMovementWithSnap(Vector3 aHandlePos, Matrix4x4 aInvMat, int i, Ferr2D_Path aPath)
    {
        if (!(Event.current.control && Ferr2DT_Menu.SnapMode == Ferr2DT_Menu.SnapType.SnapRelative))
        {
            aHandlePos = GetRealPoint(aHandlePos, aPath.transform);
        }

        Vector3 global = aHandlePos;

        if (Event.current.control && Ferr2DT_Menu.SnapMode == Ferr2DT_Menu.SnapType.SnapGlobal)
        {
            global = SnapVector(global, snap);
        }
        Vector3 local = aInvMat.MultiplyPoint3x4(global);

        if (Event.current.control && Ferr2DT_Menu.SnapMode == Ferr2DT_Menu.SnapType.SnapLocal)
        {
            local = SnapVector(local, snap);
        }
        if (!Event.current.control && Ferr2DT_Menu.SmartSnap)
        {
            local = SmartSnap(local, aPath.pathVerts, selectedPoints, Ferr2DT_Menu.SmartSnapDist);
        }

        return(new Vector2(local.x, local.y) - aPath.pathVerts[i]);
    }
예제 #17
0
 private void UpdateDependentsSmart(Ferr2D_Path aPath, bool aForce) {
     if (aForce || Ferr_Menu.UpdateTerrainSkipFrames == 0 || updateCount % Ferr_Menu.UpdateTerrainSkipFrames == 0) {
         aPath.UpdateDependants();
     }
     updateCount += 1;
 }
    public override void OnInspectorGUI()
    {
        Undo.RecordObject(target, "Modified Path");

        Ferr2D_Path path = (Ferr2D_Path)target;

        // if this was an undo, refresh stuff too
        if (Event.current.type == EventType.ValidateCommand)
        {
            switch (Event.current.commandName)
            {
            case "UndoRedoPerformed":

                path.UpdateDependants(true);
                if (OnChanged != null)
                {
                    OnChanged();
                }
                return;
            }
        }

        path.closed = EditorGUILayout.Toggle("Closed", path.closed);
        if (path)
        {
            // display the path verts list info
            showVerts = EditorGUILayout.Foldout(showVerts, "Path Vertices");
        }
        EditorGUI.indentLevel = 2;
        if (showVerts)
        {
            int size = EditorGUILayout.IntField("Count: ", path.pathVerts.Count);
            while (path.pathVerts.Count > size)
            {
                path.pathVerts.RemoveAt(path.pathVerts.Count - 1);
            }
            while (path.pathVerts.Count < size)
            {
                path.pathVerts.Add(new Vector2(0, 0));
            }
        }
        // draw all the verts! Long list~
        for (int i = 0; showVerts && i < path.pathVerts.Count; i++)
        {
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.LabelField("#" + i, GUILayout.Width(60));
            path.pathVerts[i] = new Vector2(
                EditorGUILayout.FloatField(path.pathVerts[i].x),
                EditorGUILayout.FloatField(path.pathVerts[i].y));
            EditorGUILayout.EndHorizontal();
        }

        // button for updating the origin of the object
        if (GUILayout.Button("Center Position"))
        {
            path.ReCenter();
        }

        bool updateClosed           = false;
        Ferr2DT_PathTerrain terrain = path.GetComponent <Ferr2DT_PathTerrain>();

        if (!path.closed && terrain != null && (terrain.fill == Ferr2DT_FillMode.Closed || terrain.fill == Ferr2DT_FillMode.InvertedClosed || terrain.fill == Ferr2DT_FillMode.FillOnlyClosed))
        {
            path.closed  = true;
            updateClosed = true;
        }
        if (terrain != null && path.closed && (terrain.fill == Ferr2DT_FillMode.FillOnlySkirt || terrain.fill == Ferr2DT_FillMode.Skirt))
        {
            path.closed  = false;
            updateClosed = true;
        }

        // update dependants when it changes
        if (GUI.changed || updateClosed)
        {
            path.UpdateDependants(false);
            EditorUtility.SetDirty(target);
        }
    }
예제 #19
0
    private void DoHandles (Ferr2D_Path path, GUIStyle iconStyle)
    {
#if FERR2D_TERRAIN
        Ferr2DT_PathTerrain terrain = path.gameObject.GetComponent<Ferr2DT_PathTerrain>();
        if (terrain) terrain.MatchOverrides();
#endif
        Quaternion inv = Quaternion.Inverse(path.transform.rotation);

        Handles.color = new Color(1, 1, 1, 0);
        for (int i = 0; i < path.pathVerts.Count; i++)
        {
            Vector3 pos = path.transform.position + path.transform.rotation * Vector3.Scale(new Vector3(path.pathVerts[i].x, path.pathVerts[i].y, 0), path.transform.localScale);

            // check if we want to remove points
            if (Event.current.control)
            {
                if (Handles.Button(pos + offset, Quaternion.identity, HandleScale(pos+offset), HandleScale(pos+offset), Handles.CircleCap))
                {
                    path.pathVerts.RemoveAt(i);
#if FERR2D_TERRAIN
                    if (terrain)
                        terrain.directionOverrides.RemoveAt(i);
#endif
                    i--;
                    GUI.changed = true;
                }
                if (SetScale(pos + offset, texMinus, ref iconStyle)) Handles.Label(pos + offset, new GUIContent(texMinus), iconStyle);
            }
            else
            {
                // check for moving the point
                if (SetScale(pos + offset, texMinus, ref iconStyle)) Handles.Label(pos + offset, new GUIContent(texDot), iconStyle);
                Vector3 result = Handles.FreeMoveHandle(
                    pos + offset,
                    Quaternion.identity,
                    HandleScale(pos+offset),
                    Vector3.zero, Handles.CircleCap);

                Vector3 global = (result - offset);
                if (Ferr_Menu.SnapMode == Ferr2DT_SnapMode.Global) global = SnapVector(global);
                Vector3 local = inv * (global - path.transform.position);
                if (Ferr_Menu.SnapMode == Ferr2DT_SnapMode.Local ) local  = SnapVector(local);
                path.pathVerts[i] = new Vector2(
                    local.x / path.transform.localScale.x,
                    local.y / path.transform.localScale.y);

                // if using terrain, check to see for any edge overrides
#if FERR2D_TERRAIN
                if (terrain && i+1 < path.pathVerts.Count) {
                    float scale = HandleScale(pos+offset) * 0.5f;
                    Vector3 dirOff = Vector3.zero;
                    if (i + 1 < path.pathVerts.Count || path.closed == true) {
                        int index = path.closed && i + 1 == path.pathVerts.Count ? 0 : i + 1;
                        Vector3 delta = path.pathVerts[index] - path.pathVerts[i];
                        delta.Normalize();
                        Vector3 norm = new Vector3(-delta.y, delta.x, 0);
                        dirOff = delta * scale * 3 + new Vector3(norm.x, norm.y, 0) * scale * 2;
                    }

                    if (SetScale(pos + offset + dirOff, texMinus, ref iconStyle, 0.5f)) Handles.Label(pos + offset + dirOff, new GUIContent(GetDirIcon(terrain.directionOverrides[i])), iconStyle);
                    if (Handles.Button( pos + offset + dirOff, Quaternion.identity, scale, scale, Handles.CircleCap)) {
                        terrain.directionOverrides[i] = NextDir(terrain.directionOverrides[i]);
                        GUI.changed = true;
                    }
                }
#endif

                // make sure we can add new point at the midpoints!
                if (i + 1 < path.pathVerts.Count || path.closed == true)
                {
                    int index = path.closed && i + 1 == path.pathVerts.Count ? 0 : i + 1;
                    Vector3 pos2 = path.transform.position + path.transform.rotation * Vector3.Scale(new Vector3(path.pathVerts[index].x, path.pathVerts[index].y, 0), path.transform.localScale);
                    Vector3 mid  = (pos + pos2) / 2;

                    if (Handles.Button(mid + offset, Quaternion.identity, HandleScale(mid+offset), HandleScale(mid+offset), Handles.CircleCap))
                    {
                        path.pathVerts.Insert(index, inv * new Vector2((mid.x - path.transform.position.x) / path.transform.localScale.x, (mid.y - path.transform.position.y) / path.transform.localScale.y));
#if FERR2D_TERRAIN
                        if (terrain)
                            terrain.directionOverrides.Insert(index, Ferr2DT_TerrainDirection.None);
#endif
                    }
                    if (SetScale(mid + offset, texDotPlus, ref iconStyle)) Handles.Label(mid + offset, new GUIContent(texDotPlus), iconStyle);
                }
            }
        }
    }
예제 #20
0
    /// <summary>
    /// The Ferr2DT_IPath method, gets called automatically whenever the Ferr2DT path gets updated in the
    /// editor. This will completely recreate the the visual mesh (only) for the terrain. If you want
    /// To recreate the collider as well, that's a separate call to RecreateCollider.
    /// </summary>
    public void RecreatePath()
    {
        //System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
        //sw.Start();

        if (path == null)
        {
            path = GetComponent <Ferr2D_Path> ();
        }
        if (dMesh == null)
        {
            dMesh = new Ferr2DT_DynamicMesh();
        }
        if (terrainMaterial == null)
        {
            Debug.LogWarning("Cannot create terrain without a Terrain Material!");
            return;
        }

        MatchOverrides();

        // double check the materials!
        ForceMaterial(terrainMaterial, true, false);

        dMesh.Clear();
        dMesh.color = vertexColor;

        if (path.Count < 2)
        {
            GetComponent <MeshFilter>().sharedMesh = null;
            return;
        }

        // make sure we can keep a consistent scale for the texture
        if (terrainMaterial.edgeMaterial.mainTexture != null && terrainMaterial.edgeMaterial.mainTexture != null)
        {
            unitsPerUV.x = terrainMaterial.edgeMaterial.mainTexture.width / pixelsPerUnit;
            unitsPerUV.y = terrainMaterial.edgeMaterial.mainTexture.height / pixelsPerUnit;
        }

        if (fill != Ferr2DT_FillMode.FillOnlyClosed && fill != Ferr2DT_FillMode.FillOnlySkirt)
        {
            // split the path into segments based on the split angle
            List <List <Vector2> >          segments = new List <List <Vector2> >           ();
            List <Ferr2DT_TerrainDirection> dirs     = new List <Ferr2DT_TerrainDirection>();

            segments = GetSegments(path.GetVerts(smoothPath, splitDist, splitCorners), out dirs);
            if (dirs.Count < segments.Count)
            {
                dirs.Add(directionOverrides[directionOverrides.Count - 1]);
            }
            List <int> order = new List <int>();
            for (int i = 0; i < segments.Count; i++)
            {
                order.Add(i);
            }

            order.Sort(
                new Ferr2DT_Comparer <int>(
                    (x, y) => GetDescription(segments[y]).zOffset.CompareTo(GetDescription(segments[x]).zOffset)
                    ));

            // process the segments into meshes
            for (int i = 0; i < order.Count; i++)
            {
                AddSegment(segments[order[i]], order.Count <= 1 && path.closed, dirs[order[i]]);
            }
        }
        int[] submesh1 = dMesh.GetCurrentTriangleList();

        // add a fill if the user desires
        if ((fill == Ferr2DT_FillMode.Skirt || fill == Ferr2DT_FillMode.FillOnlySkirt) && terrainMaterial.fillMaterial != null)
        {
            AddFill(true);
        }
        else if ((fill == Ferr2DT_FillMode.Closed || fill == Ferr2DT_FillMode.InvertedClosed || fill == Ferr2DT_FillMode.FillOnlyClosed) && terrainMaterial.fillMaterial != null)
        {
            AddFill(false);
        }
        else if (fill == Ferr2DT_FillMode.None)
        {
        }
        int[] submesh2 = dMesh.GetCurrentTriangleList(submesh1.Length);

        // compile the mesh!
        Mesh   m    = GetComponent <MeshFilter>().sharedMesh;
        string name = "Ferr2DT_PathMesh_" + gameObject.name + gameObject.GetInstanceID();

        if (m == null || m.name != name)
        {
            GetComponent <MeshFilter>().sharedMesh = m = new Mesh();
            m.name = name;
        }
        dMesh.Build(ref m);

        // set up submeshes and submaterials
        m.subMeshCount = 2;
        if (renderer.sharedMaterials.Length < 2)
        {
            Material[] old = renderer.sharedMaterials;
            renderer.sharedMaterials = new Material[2];
            if (old.Length > 0)
            {
                renderer.sharedMaterials[0] = old[0];
            }
        }
        m.SetTriangles(submesh1, 1);
        m.SetTriangles(submesh2, 0);
        //sw.Stop();
        //Debug.Log("Creating mesh took: " + sw.Elapsed.TotalMilliseconds + "ms");
    }
예제 #21
0
    List <Vector2> OffsetColliderVerts(List <Vector2> aSegment, List <float> aSegmentScales, Ferr2DT_TerrainDirection aDir)
    {
        List <Vector2> result = new List <Vector2>(aSegment);
        int            count  = aSegment.Count;

        for (int v = count - 1; v >= 0; v--)
        {
            Vector2 norm  = smoothPath ? Ferr2D_Path.HermiteGetNormal(aSegment, v, 0, false) : Ferr2D_Path.GetNormal(aSegment, v, false);
            float   scale = v >= aSegmentScales.Count ? 1 : aSegmentScales[v];
            if (fill == Ferr2DT_FillMode.None)
            {
                result.Add(aSegment[v] + new Vector2(norm.x * surfaceOffset[(int)Ferr2DT_TerrainDirection.Top], norm.y * surfaceOffset[(int)Ferr2DT_TerrainDirection.Top]) * scale);
                result[v] += new Vector2(norm.x * -surfaceOffset[(int)Ferr2DT_TerrainDirection.Bottom], norm.y * -surfaceOffset[(int)Ferr2DT_TerrainDirection.Bottom]) * scale;
            }
            else
            {
                float   dist   = surfaceOffset[(int)aDir];
                Vector2 offset = new Vector2(dist, dist);
                result[v] += new Vector2(norm.x * -offset.x, norm.y * -offset.y) * scale;
            }
        }
        return(result);
    }
예제 #22
0
	private void    DoHandles            (Ferr2D_Path path, GUIStyle iconStyle)
	{
        Vector3             snap         = Event.current.control ? new Vector3(EditorPrefs.GetFloat("MoveSnapX"), EditorPrefs.GetFloat("MoveSnapY"), EditorPrefs.GetFloat("MoveSnapZ")) : Vector3.zero;
        Transform           transform    = path.transform;
        Matrix4x4           mat          = transform.localToWorldMatrix;
        Matrix4x4           invMat       = transform.worldToLocalMatrix;
        Transform           camTransform = SceneView.lastActiveSceneView.camera.transform;
		Ferr2DT_PathTerrain terrain      = path.GetComponent<Ferr2DT_PathTerrain>();
		if (terrain) terrain.MatchOverrides();
		
		Handles.color = new Color(1, 1, 1, 1);
		for (int i = 0; i < path.pathVerts.Count; i++)
		{
			Vector3 pos        = mat.MultiplyPoint3x4(path.pathVerts[i]);
			Vector3 posStart   = pos;
			bool    isSelected = false;
               if (selectedPoints!= null) isSelected = selectedPoints.Contains(i);
			
            // check if we want to remove points
			if (Event.current.alt)
			{
				float                   handleScale = HandleScale(posStart);
				Handles.DrawCapFunction cap         = (isSelected || selectedPoints.Count <= 0) ? (Handles.DrawCapFunction)CapDotMinusSelected : (Handles.DrawCapFunction)CapDotMinus;
				if (Handles.Button(posStart, camTransform.rotation, handleScale, handleScale, cap))
				{
					if (!isSelected) {
						selectedPoints.Clear();
						selectedPoints.Add(i);
					}
					for (int s = 0; s < selectedPoints.Count; s++) {
						if (terrain) terrain.RemovePoint(selectedPoints[s]);
						else  path.pathVerts.RemoveAt   (selectedPoints[s]);
						if (selectedPoints[s] <= i) i--;
						
						for (int u = 0; u < selectedPoints.Count; u++) {
							if (selectedPoints[u] > selectedPoints[s]) selectedPoints[u] -= 1;
						}
					}
					selectedPoints.Clear();
					GUI.changed = true;
				} else if (Ferr2DT_SceneOverlay.editMode != Ferr2DT_EditMode.None) {
					
					if (terrain && i+1 < path.pathVerts.Count) {
						float   scale     = handleScale * 0.5f;
						Vector3 dirOff    = GetTickerOffset(path, pos, i);
						Vector3 posDirOff = posStart + dirOff;
						
						if (IsVisible(posDirOff)) {
							cap = null;
							if      (Ferr2DT_SceneOverlay.editMode == Ferr2DT_EditMode.Override) cap  = GetDirIcon(terrain.directionOverrides[i]);
							else if (Ferr2DT_SceneOverlay.editMode == Ferr2DT_EditMode.Scale   ) cap  = CapDotScale;
							if      (Event.current.alt)                                          cap  = CapDotReset;
							
							if (Handles.Button(posDirOff, camTransform.rotation, scale, scale, cap)) {
								if (selectedPoints.Count < 2 || isSelected == false) {
									selectedPoints.Clear();
									selectedPoints.Add(i);
									isSelected = true;
								}
								
								for (int s = 0; s < selectedPoints.Count; s++) {
									if (Ferr2DT_SceneOverlay.editMode == Ferr2DT_EditMode.Override)
										terrain.directionOverrides[selectedPoints[s]] = Ferr2DT_TerrainDirection.None;
									else if (Ferr2DT_SceneOverlay.editMode == Ferr2DT_EditMode.Scale)
										terrain.vertScales        [selectedPoints[s]] = 1;
								}
								GUI.changed = true;
							}
						}
					}
				}
			} else {
                // check for moving the point
				Handles.DrawCapFunction cap = CapDot;
				if (Event.current.control) cap = isSelected ? (Handles.DrawCapFunction)CapDotSelectedSnap : (Handles.DrawCapFunction)CapDotSnap;
				else                       cap = isSelected ? (Handles.DrawCapFunction)CapDotSelected     : (Handles.DrawCapFunction)CapDot;
				
				Vector3 result = Handles.FreeMoveHandle(
					posStart,
					camTransform.rotation,
					HandleScale(pos),
					snap, 
					cap);
				
				if (result != posStart) {
					
					if (selectedPoints.Count < 2 || isSelected == false) {
						selectedPoints.Clear();
						selectedPoints.Add(i);
						isSelected = true;
					}
					
					if (!(Event.current.control && Ferr2DT_Menu.SnapMode == Ferr2DT_Menu.SnapType.SnapRelative))
						result = GetRealPoint(result, transform);

					Vector3 global = result;
					if (Event.current.control && Ferr2DT_Menu.SnapMode == Ferr2DT_Menu.SnapType.SnapGlobal) global = SnapVector(global, snap);
					Vector3 local  = invMat.MultiplyPoint3x4(global);
					if (Event.current.control && Ferr2DT_Menu.SnapMode == Ferr2DT_Menu.SnapType.SnapLocal ) local  = SnapVector(local, snap);
					if (!Event.current.control && Ferr2DT_SceneOverlay.smartSnap) {
						local = SmartSnap(local, path.pathVerts, selectedPoints, Ferr2DT_Menu.SmartSnapDist);
					}
					
					Vector2 relative = new Vector2( local.x, local.y) - path.pathVerts[i];
					
					for (int s = 0; s < selectedPoints.Count; s++) {
						path.pathVerts[selectedPoints[s]] += relative;
					}
				}
				
                // if using terrain, check to see for any edge overrides
				if (Ferr2DT_SceneOverlay.showIndices) {
					Vector3 labelPos = posStart + (Vector3)Ferr2D_Path.GetNormal(path.pathVerts, i, path.closed);
					Handles.color    = Color.white;
					Handles.Label(labelPos, "" + i);
					Handles.color    = new Color(1, 1, 1, 0);
				}
				
				if (terrain) {
					float   scale     = HandleScale (pos) * 0.5f;
					Vector3 dirOff    = GetTickerOffset (path, pos, i);
					Vector3 posDirOff = posStart + dirOff;
					
					if (Ferr2DT_SceneOverlay.editMode == Ferr2DT_EditMode.Override && i+1 < path.pathVerts.Count) {
						if (IsVisible(posDirOff) && terrain.directionOverrides != null) {
							cap = Event.current.alt ? (Handles.DrawCapFunction)CapDotReset : GetDirIcon(terrain.directionOverrides[i]);
							if (Handles.Button(posDirOff, camTransform.rotation, scale, scale, cap)) {
								if (selectedPoints.Count < 2 || isSelected == false) {
									selectedPoints.Clear();
									selectedPoints.Add(i);
									isSelected = true;
								}
								
								Ferr2DT_TerrainDirection dir = NextDir(terrain.directionOverrides[i]);
								for (int s = 0; s < selectedPoints.Count; s++) {
									terrain.directionOverrides[selectedPoints[s]] = dir;
								}
								GUI.changed = true;
							}
						}
						
					} else if (Ferr2DT_SceneOverlay.editMode == Ferr2DT_EditMode.Scale) {
						if (IsVisible(posDirOff)) {
                            cap = Event.current.alt ? (Handles.DrawCapFunction)CapDotReset : (Handles.DrawCapFunction)CapDotScale;
							
							Vector3 scaleMove = Handles.FreeMoveHandle(posDirOff, camTransform.rotation, scale, Vector3.zero, cap);
							float   scaleAmt  = scaleMove.y - posDirOff.y;
							if (Mathf.Abs(scaleAmt) > 0.01f ) {
								if (selectedPoints.Count < 2 || isSelected == false) {
									selectedPoints.Clear();
									selectedPoints.Add(i);
									isSelected = true;
								}
								
								float vertScale = terrain.vertScales[i] - Event.current.delta.y / 100f;
								vertScale = Mathf.Clamp(vertScale, 0.2f, 3f);
								for (int s = 0; s < selectedPoints.Count; s++) {
									terrain.vertScales[selectedPoints[s]] = vertScale;
								}
								GUI.changed = true;
							}
						}
					}
				}
				
                // make sure we can add new point at the midpoints!
				if (i + 1 < path.pathVerts.Count || path.closed == true) {
					int     index       = path.closed && i + 1 == path.pathVerts.Count ? 0 : i + 1;
					Vector3 pos2        = mat.MultiplyPoint3x4(path.pathVerts[index]);
					Vector3 mid         = (pos + pos2) / 2;
					float   handleScale = HandleScale(mid);
					
					if (Handles.Button(mid, camTransform.rotation, handleScale, handleScale, CapDotPlus)) {
						Vector2 pt = invMat.MultiplyPoint3x4(mid);
						if (terrain)
							terrain.AddPoint(pt, index);
						else
							path.pathVerts.Insert(index, pt);
					}
				}
			}
		}
		
		if (Event.current.type == EventType.keyDown && Event.current.keyCode == KeyCode.Delete && selectedPoints.Count > 0) {
			for (int s = 0; s < selectedPoints.Count; s++) {
				if (terrain) terrain.RemovePoint(selectedPoints[s]);
				else  path.pathVerts.RemoveAt   (selectedPoints[s]);
				
				for (int u = 0; u < selectedPoints.Count; u++) {
					if (selectedPoints[u] > selectedPoints[s]) selectedPoints[u] -= 1;
				}
			}
			selectedPoints.Clear();
			GUI.changed = true;
			Event.current.Use();
		}
	}
예제 #23
0
    private void SlicedQuad(List <Vector2> aSegment, int aVert, float aStart, float aEnd, int aCuts, bool aSmoothed, bool aClosed, Ferr2DT_SegmentDescription aDesc, float aStartScale, float aEndScale)
    {
        Vector2[] pos    = new Vector2[aCuts];
        Vector2[] norm   = new Vector2[aCuts];
        float  [] scales = new float  [aCuts];
        Vector3   tn1    = Ferr2D_Path.GetNormal(aSegment, aVert, aClosed);
        Vector3   tn2    = Ferr2D_Path.GetNormal(aSegment, aVert + 1, aClosed);

        // get the data needed to make the quad
        for (int i = 0; i < aCuts; i++)
        {
            float percent = aStart + (i / (float)(aCuts - 1)) * (aEnd - aStart);
            if (aSmoothed)
            {
                pos [i] = Ferr2D_Path.HermiteGetPt(aSegment, aVert, percent, aClosed);
                norm[i] = Ferr2D_Path.HermiteGetNormal(aSegment, aVert, percent, aClosed);
            }
            else
            {
                pos [i] = Vector2.Lerp(aSegment[aVert], aSegment[aVert + 1], percent);
                norm[i] = Vector2.Lerp(tn1, tn2, percent);
            }
            scales[i] = Mathf.Lerp(aStartScale, aEndScale, (i / (float)(aCuts - 1)));
        }

        int tSeed = 0;

        if (randomByWorldCoordinates)
        {
            tSeed = UnityEngine.Random.seed;
            UnityEngine.Random.seed = (int)(pos[0].x * 700000 + pos[0].y * 30000);
        }

        Rect  body = terrainMaterial.ToUV(aDesc.body[UnityEngine.Random.Range(0, aDesc.body.Length)]);
        float d    = (body.height / 2) * unitsPerUV.y;
        float yOff = fill == Ferr2DT_FillMode.InvertedClosed ? -aDesc.yOffset : aDesc.yOffset;

        if (randomByWorldCoordinates)
        {
            UnityEngine.Random.seed = tSeed;
        }

        // put the data together into a mesh
        int p1 = 0, p2 = 0, p3 = 0;

        for (int i = 0; i < aCuts; i++)
        {
            float percent = (i / (float)(aCuts - 1));

            Vector3 pos1 = pos [i];
            Vector3 n1   = norm[i];
            int     v1   = DMesh.AddVertex(pos1.x + n1.x * (d * scales[i] + yOff), pos1.y + n1.y * (d * scales[i] + yOff), -slantAmount + aDesc.zOffset, Mathf.Lerp(body.x, body.xMax, percent), fill == Ferr2DT_FillMode.InvertedClosed ? body.yMax : body.y);
            int     v2   = DMesh.AddVertex(pos1.x - n1.x * (d * scales[i] - yOff), pos1.y - n1.y * (d * scales[i] - yOff), slantAmount + aDesc.zOffset, Mathf.Lerp(body.x, body.xMax, percent), fill == Ferr2DT_FillMode.InvertedClosed ? body.y    : body.yMax);
            int     v3   = splitMiddle ? DMesh.AddVertex(pos1.x + n1.x * yOff, pos1.y + n1.y * yOff, aDesc.zOffset, Mathf.Lerp(body.x, body.xMax, percent), Mathf.Lerp(body.y, body.yMax, 0.5f)) : -1;

            if (i != 0)
            {
                if (!splitMiddle)
                {
                    DMesh.AddFace(v2, p2, p1, v1);
                }
                else
                {
                    DMesh.AddFace(v2, p2, p3, v3);
                    DMesh.AddFace(v3, p3, p1, v1);
                }
            }

            p1 = v1;
            p2 = v2;
            p3 = v3;
        }
    }
예제 #24
0
    private void DoHandles(Ferr2D_Path path, GUIStyle iconStyle)
    {
        Ferr2DT_PathTerrain terrain = path.gameObject.GetComponent<Ferr2DT_PathTerrain>();
        if (terrain) terrain.MatchOverrides();
        Quaternion inv = Quaternion.Inverse(path.transform.rotation);

        Handles.color = new Color(1, 1, 1, 0);
        for (int i = 0; i < path.pathVerts.Count; i++)
        {
            Vector3 pos        = path.transform.position + path.transform.rotation * Vector3.Scale(new Vector3(path.pathVerts[i].x, path.pathVerts[i].y, 0), path.transform.localScale);
            Vector3 posOff     = pos + offset;
            bool    isSelected = selectedPoints.Contains(i);

            // check if we want to remove points
            if (Event.current.alt)
            {
                float handleScale = HandleScale(posOff);
                if (IsVisible(posOff)) {
                    SetScale(posOff, texMinus, ref iconStyle);
                    Handles.Label(posOff, new GUIContent((isSelected || selectedPoints.Count <= 0) ? texMinusSelected : texMinus), iconStyle);
                }

                if (Handles.Button(posOff, SceneView.lastActiveSceneView.camera.transform.rotation, handleScale, handleScale, Handles.CircleCap))
                {
                    if (!isSelected) {
                        selectedPoints.Clear();
                        selectedPoints.Add(i);
                    }
                    for (int s = 0; s < selectedPoints.Count; s++) {
                        if (terrain) terrain.RemovePoint(selectedPoints[s]);
                        else  path.pathVerts.RemoveAt   (selectedPoints[s]);
                        if (selectedPoints[s] <= i) i--;

                        for (int u = 0; u < selectedPoints.Count; u++) {
                            if (selectedPoints[u] > selectedPoints[s]) selectedPoints[u] -= 1;
                        }
                    }
                    selectedPoints.Clear();
                    GUI.changed = true;
                } else if (Ferr2DT_SceneOverlay.editMode != Ferr2DT_EditMode.None) {

                    if (terrain && i+1 < path.pathVerts.Count) {
                        float   scale     = handleScale * 0.5f;
                        Vector3 dirOff    = GetTickerOffset(path, pos, i);
                        Vector3 posDirOff = posOff + dirOff;

                        if (IsVisible(posDirOff)) {
                            Texture2D icon = null;
                            if      (Ferr2DT_SceneOverlay.editMode == Ferr2DT_EditMode.Override) icon = GetDirIcon(terrain.directionOverrides[i]);
                            else if (Ferr2DT_SceneOverlay.editMode == Ferr2DT_EditMode.Scale   ) icon = texScale;
                            if      (Event.current.alt)                                          icon = texReset;

                            SetScale(posDirOff, icon, ref iconStyle, 0.5f);
                            Handles.Label(posDirOff, new GUIContent(icon), iconStyle);

                            if (Handles.Button(posDirOff, SceneView.lastActiveSceneView.camera.transform.rotation, scale, scale, Handles.CircleCap)) {
                                if (selectedPoints.Count < 2 || isSelected == false) {
                                    selectedPoints.Clear();
                                    selectedPoints.Add(i);
                                    isSelected = true;
                                }

                                for (int s = 0; s < selectedPoints.Count; s++) {
                                    if (Ferr2DT_SceneOverlay.editMode == Ferr2DT_EditMode.Override)
                                        terrain.directionOverrides[selectedPoints[s]] = Ferr2DT_TerrainDirection.None;
                                    else if (Ferr2DT_SceneOverlay.editMode == Ferr2DT_EditMode.Scale)
                                        terrain.vertScales        [selectedPoints[s]] = 1;
                                }
                                GUI.changed = true;
                            }
                        }
                    }
                }
            } else {
                // check for moving the point
                Texture2D tex = null;
                if (Event.current.control) tex = isSelected ? texDotSelectedSnap : texDotSnap;
                else                       tex = isSelected ? texDotSelected     : texDot;

                if (IsVisible(posOff)) {
                    SetScale(posOff, texMinus, ref iconStyle);
                    Handles.Label(posOff, new GUIContent(tex), iconStyle);
                }
                Vector3 snap   = Event.current.control && Ferr_Menu.SnapMode == Ferr2DT_SnapMode.SnapRelative ? new Vector3(EditorPrefs.GetFloat("MoveSnapX"), EditorPrefs.GetFloat("MoveSnapY"), EditorPrefs.GetFloat("MoveSnapZ")) : Vector3.zero;
                Vector3 result = Handles.FreeMoveHandle(
                    posOff,
                    SceneView.lastActiveSceneView.camera.transform.rotation,
                    HandleScale(pos+offset),
                    snap,
                    Handles.CircleCap);

                if (result != posOff) {

                    if (selectedPoints.Count < 2 || isSelected == false) {
                        selectedPoints.Clear();
                        selectedPoints.Add(i);
                        isSelected = true;
                    }

                    if (!(Event.current.control && Ferr_Menu.SnapMode == Ferr2DT_SnapMode.SnapRelative))
                        result = GetRealPoint(result, path.transform.position.z);
                    Vector3 global = (result - offset);
                    if (Event.current.control && Ferr_Menu.SnapMode == Ferr2DT_SnapMode.SnapGlobal) global = SnapVector(global);
                    Vector3 local  = inv * (global - path.transform.position);
                    if (Event.current.control && Ferr_Menu.SnapMode == Ferr2DT_SnapMode.SnapLocal ) local  = SnapVector(local);
                    if (!Event.current.control && Ferr2DT_SceneOverlay.smartSnap) {
                        local = SmartSnap(local, path.pathVerts, selectedPoints, Ferr_Menu.SmartSnapDist);
                    }

                    Vector2 relative = new Vector2(
                        local.x / path.transform.localScale.x,
                        local.y / path.transform.localScale.y) - path.pathVerts[i];

                    for (int s = 0; s < selectedPoints.Count; s++) {
                        path.pathVerts[selectedPoints[s]] += relative;
                    }
                }

                // if using terrain, check to see for any edge overrides
                if (Ferr2DT_SceneOverlay.showIndices) {
                    Vector3 labelPos = posOff + (Vector3)Ferr2D_Path.GetNormal(path.pathVerts, i, path.closed);
                    Handles.color    = Color.white;
                    Handles.Label(labelPos, "" + i);
                    Handles.color    = new Color(1, 1, 1, 0);
                }

                if (terrain) {// && i+1 < path.pathVerts.Count) {
                    float   scale     = HandleScale    (pos+offset) * 0.5f;
                    Vector3 dirOff    = GetTickerOffset(path, pos, i);
                    Vector3 posDirOff = posOff + dirOff;

                    if (Ferr2DT_SceneOverlay.editMode == Ferr2DT_EditMode.Override && i+1 < path.pathVerts.Count) {
                        if (IsVisible(posDirOff)) {
                            SetScale(posDirOff, texMinus, ref iconStyle, 0.5f);
                            Handles.Label(posDirOff, new GUIContent(Event.current.alt ? texReset : GetDirIcon(terrain.directionOverrides[i])), iconStyle);

                            if (Handles.Button(posDirOff, SceneView.lastActiveSceneView.camera.transform.rotation, scale, scale, Handles.CircleCap)) {
                                if (selectedPoints.Count < 2 || isSelected == false) {
                                    selectedPoints.Clear();
                                    selectedPoints.Add(i);
                                    isSelected = true;
                                }

                                Ferr2DT_TerrainDirection dir = NextDir(terrain.directionOverrides[i]);
                                for (int s = 0; s < selectedPoints.Count; s++) {
                                    terrain.directionOverrides[selectedPoints[s]] = dir;
                                }
                                GUI.changed = true;
                            }
                        }

                    } else if (Ferr2DT_SceneOverlay.editMode == Ferr2DT_EditMode.Scale) {
                        if (IsVisible(posDirOff)) {
                            SetScale(posDirOff, texMinus, ref iconStyle, 0.5f);
                            Handles.Label(posDirOff, new GUIContent(Event.current.alt ? texReset : texScale), iconStyle);

                            Vector3 scaleMove = Handles.FreeMoveHandle(posDirOff, SceneView.lastActiveSceneView.camera.transform.rotation, scale, Vector3.zero, Handles.CircleCap);
                            float   scaleAmt  = scaleMove.y - posDirOff.y;
                            if (Mathf.Abs(scaleAmt) > 0.01f ) {
                                if (selectedPoints.Count < 2 || isSelected == false) {
                                    selectedPoints.Clear();
                                    selectedPoints.Add(i);
                                    isSelected = true;
                                }

                                float vertScale = terrain.vertScales[i] - Event.current.delta.y / 100f;
                                vertScale = Mathf.Clamp(vertScale, 0.2f, 3f);
                                for (int s = 0; s < selectedPoints.Count; s++) {
                                    terrain.vertScales[selectedPoints[s]] = vertScale;
                                }
                                GUI.changed = true;
                            }
                        }
                    }
                }

                // make sure we can add new point at the midpoints!
                if (i + 1 < path.pathVerts.Count || path.closed == true) {
                    int     index       = path.closed && i + 1 == path.pathVerts.Count ? 0 : i + 1;
                    Vector3 pos2        = path.transform.position + path.transform.rotation * Vector3.Scale(new Vector3(path.pathVerts[index].x, path.pathVerts[index].y, 0), path.transform.localScale);
                    Vector3 mid         = (pos + pos2) / 2;
                    float   handleScale = HandleScale(mid + offset);

                    if (Handles.Button(mid + offset, SceneView.lastActiveSceneView.camera.transform.rotation, handleScale, handleScale, Handles.CircleCap)) {
                        Vector2 pt = inv * new Vector2((mid.x - path.transform.position.x) / path.transform.localScale.x, (mid.y - path.transform.position.y) / path.transform.localScale.y);
                        if (terrain)
                            terrain.AddPoint(pt, index);
                        else
                            path.pathVerts.Insert(index, pt);
                    }
                    if (IsVisible(mid + offset)) {
                        SetScale(mid + offset, texDotPlus, ref iconStyle);
                        Handles.Label(mid + offset, new GUIContent(texDotPlus), iconStyle);
                    }
                }
            }
        }

        if (Event.current.type == EventType.keyDown && Event.current.keyCode == KeyCode.Delete && selectedPoints.Count > 0) {
            for (int s = 0; s < selectedPoints.Count; s++) {
                if (terrain) terrain.RemovePoint(selectedPoints[s]);
                else  path.pathVerts.RemoveAt   (selectedPoints[s]);

                for (int u = 0; u < selectedPoints.Count; u++) {
                    if (selectedPoints[u] > selectedPoints[s]) selectedPoints[u] -= 1;
                }
            }
            selectedPoints.Clear();
            GUI.changed = true;
            Event.current.Use();
        }
    }
예제 #25
0
    private void DoShiftAdd(Ferr2D_Path path, GUIStyle iconStyle)
    {
#if FERR2D_TERRAIN
        Ferr2DT_PathTerrain terrain = path.gameObject.GetComponent<Ferr2DT_PathTerrain>();
#endif

        Vector2 pos = GetMousePos(Event.current.mousePosition, path.transform.position.z) - new Vector2(path.transform.position.x, path.transform.position.y);

        int closestID = path.GetClosestSeg(new Vector2(pos.x / path.transform.localScale.x, pos.y / path.transform.localScale.y));
        int secondID  = closestID + 1 >= path.Count ? 0 : closestID + 1;

        float firstDist  = Vector2.Distance(pos, path.pathVerts[closestID]);
        float secondDist = Vector2.Distance(pos, path.pathVerts[secondID]);

        Handles.color = Color.white;
        if (!(secondID == 0 && !path.closed && firstDist > secondDist))
        {
            Handles.DrawLine(
                path.transform.position + new Vector3(pos.x, pos.y, 0),
                path.transform.position + Vector3.Scale(new Vector3(path.pathVerts[closestID].x, path.pathVerts[closestID].y, 0), path.transform.localScale));
        }
        if (!(secondID == 0 && !path.closed && firstDist < secondDist))
        {
            Handles.DrawLine(
                path.transform.position + new Vector3(pos.x, pos.y, 0),
                path.transform.position + Vector3.Scale(new Vector3(path.pathVerts[secondID].x, path.pathVerts[secondID].y, 0), path.transform.localScale));
        }
        Handles.color = new Color(1, 1, 1, 0);

        Vector3 handlePos = new Vector3(pos.x, pos.y, 0) + path.transform.position + offset;
        if (Handles.Button(handlePos, Quaternion.identity, HandleScale(handlePos), HandleScale(handlePos), Handles.CircleCap))
        {
            if (secondID == 0)
            {
                if (firstDist < secondDist)
                {
                    path.pathVerts.Add(new Vector2(pos.x / path.transform.localScale.x, pos.y / path.transform.localScale.y));
#if FERR2D_TERRAIN
                    if (terrain)
                        terrain.directionOverrides.Add(Ferr2DT_TerrainDirection.None);
#endif
                }
                else
                {
                    path.pathVerts.Insert(0, new Vector2(pos.x / path.transform.localScale.x, pos.y / path.transform.localScale.y));
#if FERR2D_TERRAIN
                    if (terrain)
                        terrain.directionOverrides.Insert(0, Ferr2DT_TerrainDirection.None);
#endif
                }
            }
            else
            {
                path.pathVerts.Insert(Mathf.Max(closestID, secondID), new Vector2(pos.x / path.transform.localScale.x, pos.y / path.transform.localScale.y));
#if FERR2D_TERRAIN
                if (terrain)
                    terrain.directionOverrides.Insert(Mathf.Max(closestID, secondID), Ferr2DT_TerrainDirection.None);
#endif
            }
            GUI.changed = true;
        }
        if (SetScale(new Vector3(pos.x, pos.y, 0) + path.transform.position + offset, texDotPlus, ref iconStyle)) Handles.Label(new Vector3(pos.x, pos.y, 0) + path.transform.position + offset, new GUIContent(texDotPlus), iconStyle);
    }
예제 #26
0
    private void AddEdge()
    {
        // split the path into segments based on the split angle
        List <List <int>               > segments = new List <List <int>               >();
        List <Ferr2DT_TerrainDirection>  dirs     = new List <Ferr2DT_TerrainDirection>();
        List <int> order = new List <int>();

        segments = GetSegments(Path.GetVertsRaw(), out dirs);
        if (dirs.Count < segments.Count)
        {
            dirs.Add(directionOverrides[directionOverrides.Count - 1]);
        }
        for (int i = 0; i < segments.Count; i++)
        {
            order.Add(i);
        }

        order.Sort(
            new Ferr.LambdaComparer <int>(
                (x, y) => {
            Ferr2DT_TerrainDirection dirx = dirs[x] == Ferr2DT_TerrainDirection.None ? Ferr2D_Path.GetDirection(Path.pathVerts, segments[x], 0, fill == Ferr2DT_FillMode.InvertedClosed) : dirs[x];
            Ferr2DT_TerrainDirection diry = dirs[y] == Ferr2DT_TerrainDirection.None ? Ferr2D_Path.GetDirection(Path.pathVerts, segments[y], 0, fill == Ferr2DT_FillMode.InvertedClosed) : dirs[y];
            return(terrainMaterial.GetDescriptor(diry).zOffset.CompareTo(terrainMaterial.GetDescriptor(dirx).zOffset));
        }
                ));

        // process the segments into meshes
        for (int i = 0; i < order.Count; i++)
        {
            List <int> currSeg = segments[order[i]];
            List <int> prevSeg = order[i] - 1 < 0 ?  segments[segments.Count - 1] : segments[order[i] - 1];
            List <int> nextSeg = segments[(order[i] + 1) % segments.Count];

            int curr = currSeg[0];
            int prev = prevSeg[prevSeg.Count - 2];
            int next = currSeg[1];

            Vector2 p1        = Path.pathVerts[prev] - Path.pathVerts[curr];
            Vector2 p2        = Path.pathVerts[next] - Path.pathVerts[curr];
            bool    leftInner = Mathf.Atan2(p1.x * p2.y - p1.y * p2.x, Vector2.Dot(p1, p2)) < 0;

            curr = currSeg[currSeg.Count - 1];
            prev = currSeg[currSeg.Count - 2];
            next = nextSeg[1];

            p1 = Path.pathVerts[prev] - Path.pathVerts[curr];
            p2 = Path.pathVerts[next] - Path.pathVerts[curr];
            bool rightInner = Mathf.Atan2(p1.x * p2.y - p1.y * p2.x, Vector2.Dot(p1, p2)) < 0;

            AddSegment(Ferr2D_Path.IndicesToPath(Path.pathVerts, segments[order[i]]), leftInner, rightInner, GetScalesFromIndices(segments[order[i]]), order.Count <= 1 && Path.closed, smoothPath, dirs[order[i]]);
        }
    }
예제 #27
0
 private void DoPath(Ferr2D_Path path)
 {
     Handles.color = Color.white;
     List<Vector2> verts = path.GetVertsRaw();
     for (int i = 0; i < verts.Count - 1; i++)
     {
         Vector3 pos  = path.transform.position + path.transform.rotation * Vector3.Scale(new Vector3(verts[i    ].x, verts[i    ].y, 0), path.transform.localScale);
         Vector3 pos2 = path.transform.position + path.transform.rotation * Vector3.Scale(new Vector3(verts[i + 1].x, verts[i + 1].y, 0), path.transform.localScale);
         Handles.DrawLine(pos + offset, pos2 + offset);
     }
     if (path.closed)
     {
         Vector3 pos  = path.transform.position + path.transform.rotation * Vector3.Scale(new Vector3(verts[0              ].x, verts[0              ].y, 0), path.transform.localScale);
         Vector3 pos2 = path.transform.position + path.transform.rotation * Vector3.Scale(new Vector3(verts[verts.Count - 1].x, verts[verts.Count - 1].y, 0), path.transform.localScale);
         Handles.DrawLine(pos + offset, pos2 + offset);
     }
 }
예제 #28
0
    private void AddCap(List <Vector2> aSegment, Ferr2DT_SegmentDescription aDesc, bool aInner, float aDir, float aScale, bool aSmooth)
    {
        int     index = 0;
        Vector2 dir   = Vector2.zero;

        if (aDir < 0)
        {
            index = 0;
            dir   = aSegment[0] - aSegment[1];
        }
        else
        {
            index = aSegment.Count - 1;
            dir   = aSegment[aSegment.Count - 1] - aSegment[aSegment.Count - 2];
        }
        dir.Normalize();
        Vector2 norm = aSmooth ? Ferr2D_Path.HermiteGetNormal(aSegment, index, 0, false): Ferr2D_Path.GetNormal(aSegment, index, false);
        Vector2 pos  = aSegment[index];
        float   yOff = fill == Ferr2DT_FillMode.InvertedClosed ? -aDesc.yOffset : aDesc.yOffset;
        Rect    cap;

        if (aDir < 0)
        {
            if (fill == Ferr2DT_FillMode.InvertedClosed)
            {
                cap = (!aInner && aDesc.innerRightCap.width > 0) ? terrainMaterial.ToUV(aDesc.innerRightCap) : terrainMaterial.ToUV(aDesc.rightCap);
            }
            else
            {
                cap = (aInner && aDesc.innerLeftCap.width > 0) ? terrainMaterial.ToUV(aDesc.innerLeftCap) : terrainMaterial.ToUV(aDesc.leftCap);
            }
        }
        else
        {
            if (fill == Ferr2DT_FillMode.InvertedClosed)
            {
                cap = (!aInner && aDesc.innerLeftCap.width > 0) ? terrainMaterial.ToUV(aDesc.innerLeftCap) : terrainMaterial.ToUV(aDesc.leftCap);
            }
            else
            {
                cap = (aInner && aDesc.innerRightCap.width > 0) ? terrainMaterial.ToUV(aDesc.innerRightCap) : terrainMaterial.ToUV(aDesc.rightCap);
            }
        }

        float width = cap.width * unitsPerUV.x;
        float scale = (cap.height / 2) * unitsPerUV.y * aScale;

        float minU = fill == Ferr2DT_FillMode.InvertedClosed ? cap.xMax : cap.x;
        float maxU = fill == Ferr2DT_FillMode.InvertedClosed ? cap.x    : cap.xMax;
        float minV = fill == Ferr2DT_FillMode.InvertedClosed ? cap.yMax : cap.y;
        float maxV = fill == Ferr2DT_FillMode.InvertedClosed ? cap.y    : cap.yMax;

        if (aDir >= 0)
        {
            float t = minU;
            minU = maxU;
            maxU = t;
        }

        int v1 = DMesh.AddVertex(pos + dir * width + norm * (scale + yOff), -slantAmount + aDesc.zOffset, new Vector2(minU, minV));
        int v2 = DMesh.AddVertex(pos + norm * (scale + yOff), -slantAmount + aDesc.zOffset, new Vector2(maxU, minV));

        int v15 = splitMiddle ? DMesh.AddVertex(pos + dir * width + (norm * yOff), aDesc.zOffset, new Vector2(minU, cap.y + (cap.height / 2))) : -1;
        int v25 = splitMiddle ? DMesh.AddVertex(pos + (norm * yOff), aDesc.zOffset, new Vector2(maxU, cap.y + (cap.height / 2))) : -1;

        int v3 = DMesh.AddVertex(pos - norm * (scale - yOff), slantAmount + aDesc.zOffset, new Vector2(maxU, maxV));
        int v4 = DMesh.AddVertex(pos + dir * width - norm * (scale - yOff), slantAmount + aDesc.zOffset, new Vector2(minU, maxV));

        if (splitMiddle && aDir < 0)
        {
            DMesh.AddFace(v1, v2, v25, v15);
            DMesh.AddFace(v15, v25, v3, v4);
        }
        else if (splitMiddle && aDir >= 0)
        {
            DMesh.AddFace(v2, v1, v15, v25);
            DMesh.AddFace(v25, v15, v4, v3);
        }
        else if (aDir < 0)
        {
            DMesh.AddFace(v1, v2, v3, v4);
        }
        else
        {
            DMesh.AddFace(v2, v1, v4, v3);
        }
    }
예제 #29
0
    private void DoShiftAdd(Ferr2D_Path path, GUIStyle iconStyle)
    {
        Ferr2DT_PathTerrain terrain  = path.gameObject.GetComponent<Ferr2DT_PathTerrain>();
        Quaternion          inv      = Quaternion.Inverse(path.transform.rotation);
        Vector2             pos      = GetMousePos(Event.current.mousePosition, path.transform.position.z) - new Vector2(path.transform.position.x, path.transform.position.y);
        bool                hasDummy = path.pathVerts.Count <= 0;

        if (hasDummy) path.pathVerts.Add(Vector2.zero);

        int   closestID  = path.GetClosestSeg(inv * new Vector2(pos.x / path.transform.localScale.x, pos.y / path.transform.localScale.y));
        int   secondID   = closestID + 1 >= path.Count ? 0 : closestID + 1;

        float firstDist  = Vector2.Distance(pos, path.pathVerts[closestID]);
        float secondDist = Vector2.Distance(pos, path.pathVerts[secondID]);

        Vector3 local  = pos;
        if (Event.current.control && Ferr_Menu.SnapMode == Ferr2DT_SnapMode.SnapLocal ) local  = SnapVector(local );
        Vector3 global = path.transform.position + local;
        if (Event.current.control && Ferr_Menu.SnapMode == Ferr2DT_SnapMode.SnapGlobal) global = SnapVector(global);

        Handles.color = Color.white;
        if (!(secondID == 0 && !path.closed && firstDist > secondDist))
        {
            Handles.DrawLine(
                global,
                path.transform.position + path.transform.rotation * Vector3.Scale(new Vector3(path.pathVerts[closestID].x, path.pathVerts[closestID].y, 0), path.transform.localScale));
        }
        if (!(secondID == 0 && !path.closed && firstDist < secondDist))
        {
            Handles.DrawLine(
                global,
                path.transform.position + path.transform.rotation * Vector3.Scale(new Vector3(path.pathVerts[secondID].x, path.pathVerts[secondID].y, 0), path.transform.localScale));
        }
        Handles.color = new Color(1, 1, 1, 0);

        Vector3 handlePos = new Vector3(pos.x, pos.y, 0) + path.transform.position + offset;
        if (IsVisible(handlePos)) {
            if (Handles.Button(handlePos, SceneView.lastActiveSceneView.camera.transform.rotation, HandleScale(handlePos), HandleScale(handlePos), Handles.CircleCap))
            {
                Vector3    finalPos = inv * (new Vector3(global.x / path.transform.localScale.x, global.y / path.transform.localScale.y, 0) - path.transform.position);
                if (secondID == 0) {
                    if (firstDist < secondDist) {
                        if (terrain)
                            terrain.AddPoint(finalPos);
                        else
                            path.pathVerts.Add(finalPos);
                    } else {
                        if (terrain)
                            terrain.AddPoint(finalPos, 0);
                        else
                            path.pathVerts.Insert(0, finalPos);
                    }
                } else {
                    if (terrain)
                        terrain.AddPoint(finalPos, Mathf.Max(closestID, secondID));
                    else
                        path.pathVerts.Insert(Mathf.Max(closestID, secondID), finalPos);
                }
                selectedPoints.Clear();
                GUI.changed = true;
            }

            SetScale(handlePos, texDotPlus, ref iconStyle);
            Handles.Label(handlePos, new GUIContent(texDotPlus), iconStyle);
        }

        if (hasDummy) path.pathVerts.RemoveAt(0);
    }
예제 #30
0
    private void DoShiftAdd(Ferr2D_Path path, GUIStyle iconStyle)
    {
        Ferr2DT_PathTerrain terrain = path.gameObject.GetComponent <Ferr2DT_PathTerrain>();
        Quaternion          inv     = Quaternion.Inverse(path.transform.rotation);
        Vector2             pos     = GetMousePos(Event.current.mousePosition, path.transform.position.z) - new Vector2(path.transform.position.x, path.transform.position.y);
        bool hasDummy = path.pathVerts.Count <= 0;

        if (hasDummy)
        {
            path.pathVerts.Add(Vector2.zero);
        }

        int closestID = path.GetClosestSeg(inv * new Vector2(pos.x / path.transform.localScale.x, pos.y / path.transform.localScale.y));
        int secondID  = closestID + 1 >= path.Count ? 0 : closestID + 1;

        float firstDist  = Vector2.Distance(pos, path.pathVerts[closestID]);
        float secondDist = Vector2.Distance(pos, path.pathVerts[secondID]);

        Vector3 local = pos;

        if (Event.current.control && Ferr_Menu.SnapMode == Ferr2DT_SnapMode.SnapLocal)
        {
            local = SnapVector(local);
        }
        Vector3 global = path.transform.position + local;

        if (Event.current.control && Ferr_Menu.SnapMode == Ferr2DT_SnapMode.SnapGlobal)
        {
            global = SnapVector(global);
        }

        Handles.color = Color.white;
        if (!(secondID == 0 && !path.closed && firstDist > secondDist))
        {
            Handles.DrawLine(
                global,
                path.transform.position + path.transform.rotation * Vector3.Scale(new Vector3(path.pathVerts[closestID].x, path.pathVerts[closestID].y, 0), path.transform.localScale));
        }
        if (!(secondID == 0 && !path.closed && firstDist < secondDist))
        {
            Handles.DrawLine(
                global,
                path.transform.position + path.transform.rotation * Vector3.Scale(new Vector3(path.pathVerts[secondID].x, path.pathVerts[secondID].y, 0), path.transform.localScale));
        }
        Handles.color = new Color(1, 1, 1, 0);

        Vector3 handlePos = new Vector3(pos.x, pos.y, 0) + path.transform.position + offset;

        if (IsVisible(handlePos))
        {
            if (Handles.Button(handlePos, SceneView.lastActiveSceneView.camera.transform.rotation, HandleScale(handlePos), HandleScale(handlePos), Handles.CircleCap))
            {
                Vector3 finalPos = inv * (new Vector3(global.x / path.transform.localScale.x, global.y / path.transform.localScale.y, 0) - path.transform.position);
                if (secondID == 0)
                {
                    if (firstDist < secondDist)
                    {
                        if (terrain)
                        {
                            terrain.AddPoint(finalPos);
                        }
                        else
                        {
                            path.pathVerts.Add(finalPos);
                        }
                    }
                    else
                    {
                        if (terrain)
                        {
                            terrain.AddPoint(finalPos, 0);
                        }
                        else
                        {
                            path.pathVerts.Insert(0, finalPos);
                        }
                    }
                }
                else
                {
                    if (terrain)
                    {
                        terrain.AddPoint(finalPos, Mathf.Max(closestID, secondID));
                    }
                    else
                    {
                        path.pathVerts.Insert(Mathf.Max(closestID, secondID), finalPos);
                    }
                }
                if (selectedPoints != null)
                {
                    selectedPoints.Clear();
                }
                GUI.changed = true;
            }

            SetScale(handlePos, texDotPlus, ref iconStyle);
            Handles.Label(handlePos, new GUIContent(texDotPlus), iconStyle);
        }

        if (hasDummy)
        {
            path.pathVerts.RemoveAt(0);
        }
    }
예제 #31
0
    /// <summary>
    /// This method will close a list of split segments, merging and adding points to the end chunks.
    /// </summary>
    /// <param name="aSegmentList">List of split segments that make up the path.</param>
    /// <param name="aCorners">If there are corners or not.</param>
    /// <returns>A closed loop of segments.</returns>
    public static bool                     CloseEnds(List <Vector2> aPath, ref List <List <int> > aSegmentList, ref List <Ferr2DT_TerrainDirection> aSegmentDirections, bool aCorners, bool aInverted)
    {
        int     startID   = aSegmentList[0][0];
        Vector2 start     = aPath[startID];
        Vector2 startNext = aPath[aSegmentList[0][1]];

        int     endID   = aSegmentList[aSegmentList.Count - 1][aSegmentList[aSegmentList.Count - 1].Count - 1];
        Vector2 end     = aPath[endID];
        Vector2 endPrev = aPath[aSegmentList[aSegmentList.Count - 1][aSegmentList[aSegmentList.Count - 1].Count - 2]];

        if (aCorners == false)
        {
            aSegmentList[0].Add(startID);
            return(true);
        }

        bool endCorner   = Ferr2D_Path.GetDirection(endPrev, end) != Ferr2D_Path.GetDirection(end, start);
        bool startCorner = Ferr2D_Path.GetDirection(end, start) != Ferr2D_Path.GetDirection(start, startNext);

        if (endCorner && startCorner)
        {
            List <int> lastSeg = new List <int>();
            lastSeg.Add(endID);
            lastSeg.Add(startID);

            aSegmentList.Add(lastSeg);

            Ferr2DT_TerrainDirection dir = GetDirection(start, end);
            if (aInverted && dir == Ferr2DT_TerrainDirection.Top)
            {
                dir = Ferr2DT_TerrainDirection.Bottom;
            }
            if (aInverted && dir == Ferr2DT_TerrainDirection.Bottom)
            {
                dir = Ferr2DT_TerrainDirection.Top;
            }
            if (aInverted && dir == Ferr2DT_TerrainDirection.Right)
            {
                dir = Ferr2DT_TerrainDirection.Left;
            }
            if (aInverted && dir == Ferr2DT_TerrainDirection.Left)
            {
                dir = Ferr2DT_TerrainDirection.Right;
            }

            aSegmentDirections.Add(dir);
        }
        else if (endCorner && !startCorner)
        {
            aSegmentList[0].Insert(0, endID);
        }
        else if (!endCorner && startCorner)
        {
            aSegmentList[aSegmentList.Count - 1].Add(startID);
        }
        else
        {
            aSegmentList[0].InsertRange(0, aSegmentList[aSegmentList.Count - 1]);
            aSegmentList.RemoveAt(aSegmentList.Count - 1);
            aSegmentDirections.RemoveAt(aSegmentDirections.Count - 1);
        }
        return(true);
    }
예제 #32
0
    public override void OnInspectorGUI()
    {
        Ferr2D_Path path       = (Ferr2D_Path)target;
        bool        updateMesh = false;

        // if this was an undo, refresh stuff too
        if (Event.current.type == EventType.ValidateCommand)
        {
            switch (Event.current.commandName)
            {
            case "UndoRedoPerformed":

                path.UpdateDependants(true);
                if (OnChanged != null)
                {
                    OnChanged();
                }
                return;
            }
        }

        EditorGUILayout.PropertyField(closed);
        EditorGUI.BeginChangeCheck();
        EditorGUILayout.PropertyField(pathVerts, true);
        if (EditorGUI.EndChangeCheck() && PrefabUtility.GetCorrespondingObjectFromSource(target) != null)
        {
            NudgeArray(pathVerts);
        }

        // button for updating the origin of the object
        if (GUILayout.Button("Center Position"))
        {
            Undo.RecordObject(target, "Modified Path");
            path.ReCenter();
            updateMesh = true;
        }

        Ferr2DT_PathTerrain terrain = path.GetComponent <Ferr2DT_PathTerrain>();

        if (!path.closed && (terrain.fill == Ferr2DT_FillMode.Closed || terrain.fill == Ferr2DT_FillMode.InvertedClosed || terrain.fill == Ferr2DT_FillMode.FillOnlyClosed))
        {
            Undo.RecordObject(target, "Modified Path");
            path.closed = true;
            updateMesh  = true;
        }
        if (path.closed && (terrain.fill == Ferr2DT_FillMode.FillOnlySkirt || terrain.fill == Ferr2DT_FillMode.Skirt))
        {
            Undo.RecordObject(target, "Modified Path");
            path.closed = false;
            updateMesh  = true;
        }

        // update dependants when it changes
        if (updateMesh || serializedObject.ApplyModifiedProperties())
        {
            if (OnChanged != null)
            {
                OnChanged();
            }
            path.UpdateDependants(true);
            EditorUtility.SetDirty(target);
        }
    }
    private List <Vector2> LegacyOffsetColliderVerts(List <Vector2> aSegment, List <float> aSegmentScales, Ferr2DT_TerrainDirection aDir)
    {
        List <Vector2> result = new List <Vector2>(aSegment);
        int            count  = aSegment.Count;

        for (int v = count - 1; v >= 0; v--)
        {
            Vector2 norm      = smoothPath ? Ferr2D_Path.HermiteGetNormal(aSegment, v, 0, false) : Ferr2D_Path.GetNormal(aSegment, v, false);
            Vector2 segNormal = Ferr2D_Path.GetSegmentNormal(v, aSegment, false);
            float   scale     = v >= aSegmentScales.Count ? 1 : aSegmentScales[v];
            float   rootScale = smoothPath ? 1 : 1f / Mathf.Abs(Mathf.Cos(Vector2.Angle(-segNormal, norm) * Mathf.Deg2Rad));
            scale = scale * rootScale;

            if (fill == Ferr2DT_FillMode.None)
            {
                result.Add(aSegment[v] + new Vector2(norm.x * surfaceOffset[(int)Ferr2DT_TerrainDirection.Top], norm.y * surfaceOffset[(int)Ferr2DT_TerrainDirection.Top]) * scale);
                result[v] += new Vector2(norm.x * -surfaceOffset[(int)Ferr2DT_TerrainDirection.Bottom], norm.y * -surfaceOffset[(int)Ferr2DT_TerrainDirection.Bottom]) * scale;
            }
            else
            {
                float   dist   = surfaceOffset[(int)aDir];
                Vector2 offset = new Vector2(dist, dist);
                result[v] += new Vector2(norm.x * -offset.x, norm.y * -offset.y) * scale;
            }
        }
        return(result);
    }
예제 #34
0
    private void DoCutOverrideModeHandles(Ferr2D_Path path, Ferr2DT_PathTerrain terrain, Matrix4x4 mat, Transform camTransform)
    {
        List <List <int>               > segments = new List <List <int>               >();
        List <Ferr2DT_TerrainDirection>  dirs     = new List <Ferr2DT_TerrainDirection>();
        List <Vector2> rawVerts = path.GetVertsRaw();

        // cut the terrain into segments, we need segment info to draw these points
        segments = terrain.GetSegments(rawVerts, out dirs);

        for (int s = 0; s < segments.Count; s++)
        {
            List <int>     currSeg   = segments[s];
            List <Vector2> currVerts = Ferr2D_Path.IndicesToList(rawVerts, currSeg);
            List <Ferr2DT_PathTerrain.CutOverrides> overrides = Ferr2D_Path.IndicesToList(terrain.cutOverrides, currSeg);

            // find information about this segment
            Ferr2DT_TerrainDirection   currDir = dirs[s];
            Ferr2DT_SegmentDescription desc    = default(Ferr2DT_SegmentDescription);

            if (currDir != Ferr2DT_TerrainDirection.None)
            {
                desc = terrain.TerrainMaterial.GetDescriptor(currDir);
            }
            else
            {
                desc = terrain.GetDescription(currSeg);
            }

            // if there's no body segment choices, don't bother with the rest of this
            if (desc.body.Length < 2)
            {
                continue;
            }

            Vector2 capLeftSlideDir  = (currVerts[1] - currVerts[0]);
            Vector2 capRightSlideDir = (currVerts[currVerts.Count - 2] - currVerts[currVerts.Count - 1]);
            capLeftSlideDir.Normalize();
            capRightSlideDir.Normalize();
            currVerts[0] -= capLeftSlideDir * desc.capOffset;
            currVerts[currVerts.Count - 1] -= capRightSlideDir * desc.capOffset;

            float distance = Ferr2D_Path.GetSegmentLength(currVerts);

            // how many texture cuts are there on the segment
            float bodyWidth   = desc.body[0].width * (terrain.TerrainMaterial.edgeMaterial.mainTexture.width / terrain.pixelsPerUnit);
            int   textureCuts = Mathf.Max(1, Mathf.FloorToInt(distance / bodyWidth + 0.5f));

            // data is attached to the points still, check if we've switched to a new point
            int activePt       = -1;
            int activeLocalCut = -1;
            for (int c = 0; c < textureCuts; c++)
            {
                float pctGlobal = c / (float)textureCuts;

                int   ptLocal  = 0;
                float pctLocal = 0;
                Ferr2D_Path.PathGlobalPercentToLocal(currVerts, pctGlobal, out ptLocal, out pctLocal, distance, false);

                if (ptLocal != activePt)
                {
                    // if they size down, we need to shorten the data too
                    if (activePt != -1)
                    {
                        CapListSize <int>(ref overrides[activePt].data, activeLocalCut + 3);
                    }
                    activePt       = ptLocal;
                    activeLocalCut = 0;

                    if (overrides[activePt].data == null)
                    {
                        overrides[activePt].data = new List <int>();
                    }
                }

                while (activeLocalCut >= overrides[activePt].data.Count)
                {
                    overrides[activePt].data.Add(0);
                }

                CapFunction cap            = CapDotAuto;
                int         activeOverride = overrides[activePt].data[activeLocalCut];
                if (activeOverride != 0)
                {
                    if (activeOverride == 1)
                    {
                        cap = CapDot1;
                    }
                    else if (activeOverride == 2)
                    {
                        cap = CapDot2;
                    }
                    else if (activeOverride == 3)
                    {
                        cap = CapDot3;
                    }
                    else if (activeOverride == 4)
                    {
                        cap = CapDot4;
                    }
                    else if (activeOverride == 5)
                    {
                        cap = CapDot5;
                    }
                    else if (activeOverride >= 6)
                    {
                        cap = CapDotN;
                    }
                }
                if (Event.current.alt)
                {
                    cap = CapDotReset;
                }

                int   ptShow  = 0;
                float pctShow = 0;
                Ferr2D_Path.PathGlobalPercentToLocal(currVerts, pctGlobal + (1f / textureCuts) * 0.5f, out ptShow, out pctShow, distance, false);

                Vector2 pt  = Ferr2D_Path.LinearGetPt(currVerts, ptShow, pctShow, false);
                Vector3 pos = mat.MultiplyPoint3x4(pt);
                float   sc  = HandleScale(pos) * Ferr2D_Visual.SmallHandleSize;
                if (Handles.Button(pos, camTransform.rotation, sc, sc, cap))
                {
                    Undo.RecordObject(terrain, "Lock Texture Segment");

                    overrides[activePt].data[activeLocalCut] = Event.current.alt ? 0 : (activeOverride + 1) % (desc.body.Length + 1);
                    EditorUtility.SetDirty(terrain);
                    GUI.changed = true;
                }

                activeLocalCut += 1;
            }
            if (activePt != -1)
            {
                CapListSize <int>(ref overrides[activePt].data, activeLocalCut + 3);
            }
        }
    }
    public Ferr2DT_SegmentDescription  GetDescription(List <int> aSegment)
    {
        Ferr2DT_TerrainDirection dir = Ferr2D_Path.GetDirection(Path.pathVerts, aSegment, 0, fill == Ferr2DT_FillMode.InvertedClosed);

        return(TerrainMaterial.GetDescriptor(dir));
    }
예제 #36
0
    void OnTriggerExit2D(Collider2D collider)
    {
        if (collider.tag == "terrain")
        {
            if (terrainsTransform.Contains(collider.transform.position))
            {
                return;
            }
            //for (int i = 0; i < terrainsTransform.Count; i++) {
            //
            //	if (collider.transform == terrainsTransform[i]) Debug.Log(123);
            //}
            terrainsTransform.Add(collider.transform.position);
            exitPoint = transform.position;
            Vector2 diff        = exitPoint - enterPoint;
            float   pointBDiffC = Mathf.Sqrt(diff.x * diff.x + diff.y * diff.y);
            float   diffX       = 15 / pointBDiffC * diff.x;
            float   diffY       = 15 / pointBDiffC * diff.y;

            exitPoint = new Vector2(diffX, diffY) + enterPoint;
            //Debug.Log ("exit: " + collider.name + exitPoint);

            Ferr2D_Path    terrain = collider.GetComponent <Ferr2D_Path>();
            List <Vector2> pos = new List <Vector2>();
            List <int>     point = new List <int>();
            Vector2        firstPoint = new Vector2(0, 0);
            Vector2        secondPoint = new Vector2(0, 0);
            int            firstPointA = -1, secondPointA = -1;
            Vector2        posTemp, posA, posB;
            int            terrainCount = terrain.Count;
            for (int i = 0; i < terrainCount; i++)
            {
                if (i == terrainCount - 1)
                {
                    posA    = terrain.pathVerts[0] + new Vector2(collider.transform.position.x, collider.transform.position.y);
                    posB    = terrain.pathVerts[i] + new Vector2(collider.transform.position.x, collider.transform.position.y);
                    posTemp = lineIntersectPos(enterPoint, exitPoint, posA, posB);
                }
                else
                {
                    posA    = terrain.pathVerts[i + 1] + new Vector2(collider.transform.position.x, collider.transform.position.y);
                    posB    = terrain.pathVerts[i] + new Vector2(collider.transform.position.x, collider.transform.position.y);
                    posTemp = lineIntersectPos(enterPoint, exitPoint, posA, posB);
                }
                if (posTemp.x != 10000)
                {
                    if (Mathf.Abs(posTemp.x - posA.x) <= 0.02F && Mathf.Abs(posTemp.y - posA.y) <= 0.02F)
                    {
                        posTemp = posA;
                    }
                    if (Mathf.Abs(posTemp.x - posB.x) <= 0.02F && Mathf.Abs(posTemp.y - posB.y) <= 0.02F)
                    {
                        posTemp = posB;
                    }
                    //Debug.Log("enterPoint: " + enterPoint);
                    //Debug.Log("exitPoint: " + exitPoint);
                    //Debug.Log("posA: " + posA);
                    //Debug.Log("posB: " + posB);
                    //Debug.Log("pos: " + posTemp);

                    pos.Add(posTemp);
                    point.Add(i);
                }

                //Debug.Log("pos.x: " + pos.x);
            }

            //sorting
            float          minLength = 100;
            List <Vector2> posSort   = new List <Vector2>();
            List <int>     pointSort = new List <int>();
            int            j         = -1;
            for (int i = 0; i < pos.Count; i++)
            {
                for (int y = 0; y < pos.Count; y++)
                {
                    if ((pos[y] - enterPoint).magnitude < minLength)
                    {
                        minLength = (pos[y] - enterPoint).magnitude;
                        j         = y;
                    }
                }
                minLength = 100;
                posSort.Add(pos[j]);
                pos[j] = new Vector2(100, 100);
                pointSort.Add(point[j]);
            }

            for (int y = 0; y < posSort.Count - 1; y += 2)
            {
                terrain = collider.GetComponent <Ferr2D_Path>();
                int g = 0;
                if (y > 0)
                {
                    //Debug.Log("terrain.pathVerts[1]: " + terrain.pathVerts[1]);
                    //Debug.Log("posSort[y - 1]: " + posSort[y - 1]);
                    if (terrain.pathVerts[1] == posSort[y - 1] - new Vector2(collider.transform.position.x, collider.transform.position.y))
                    {
                        g = y - 1;
                    }
                    else
                    {
                        g = y - 2;
                    }
                    for (int q = y; q < posSort.Count; q++)
                    {
                        //Debug.Log ("pointSort[q]: " + pointSort[q]);
                        //Debug.Log ("pointSort[g]: " + pointSort[g]);
                        //Debug.Log ("g: " + g);
                        pointSort[q] = pointSort[q] - pointSort[g] + 1;
                        if (pointSort[q] < 0)
                        {
                            pointSort[q] += terrainCount;
                        }
                    }
                }
                firstPointA  = pointSort[y];
                secondPointA = pointSort[y + 1];
                firstPoint   = posSort[y] - new Vector2(collider.transform.position.x, collider.transform.position.y);
                secondPoint  = posSort[y + 1] - new Vector2(collider.transform.position.x, collider.transform.position.y);

                //Debug.Log ("fp: " + firstPoint);
                //Debug.Log ("sp: " + secondPoint);
                bool           flag         = true;
                int            i            = -1;
                List <Vector2> firstFigure  = new List <Vector2>();
                List <Vector2> secondFigure = new List <Vector2>();
                terrainCount = terrain.Count;
                //Debug.Log("pathVerts: ");
                //for (int e = 0; e < terrainCount; e++) Debug.Log(terrain.pathVerts[e]);

                while (flag)
                {
                    if (i == -1)
                    {
                        //i = firstPointA;
                        //Debug.Log (firstPointA);
                        firstFigure.Add(firstPoint);
                        //terrain.pathVerts.Add(firstPoint);
                        //Debug.Log (secondPointA);
                        firstFigure.Add(secondPoint);
                        i = secondPointA + 1;
                    }
                    if (i >= terrainCount)
                    {
                        i = 0;
                    }
                    if (i == firstPointA)
                    {
                        flag = false;
                    }
                    //Debug.Log (i);
                    if (terrain.pathVerts[i] != firstPoint && terrain.pathVerts[i] != secondPoint)
                    {
                        firstFigure.Add(terrain.pathVerts[i]);
                    }
                    i++;
                }
                flag = true;
                i    = -1;
                while (flag)
                {
                    if (i == -1)
                    {
                        secondFigure.Add(secondPoint);
                        secondFigure.Add(firstPoint);
                        i = firstPointA + 1;
                    }
                    if (i >= terrainCount)
                    {
                        i = 0;
                    }
                    if (i == secondPointA)
                    {
                        flag = false;
                    }
                    //Debug.Log(i);
                    if (terrain.pathVerts[i] != firstPoint && terrain.pathVerts[i] != secondPoint)
                    {
                        secondFigure.Add(terrain.pathVerts[i]);
                    }
                    i++;
                }
                terrain.pathVerts.Clear();

                if (getSq(firstFigure) >= getSq(secondFigure))
                {
                    terrain.pathVerts.AddRange(firstFigure);
                }
                else
                {
                    terrain.pathVerts.AddRange(secondFigure);
                }

                //Debug.Log (terrain.pathVerts[0]);
                //terrain.UpdateDependants();
                Ferr2DT_PathTerrain pathTerrain = collider.GetComponent <Ferr2DT_PathTerrain>();
                pathTerrain.RecreatePath();
                pathTerrain.RecreateCollider();
            }
            for (int i = 0; i < gGrootClass.terrainGrootChains.Count; i++)
            {
                gGrootClass.terrainGrootChain terr = gGrootClass.terrainGrootChains[i];
                if (terr.terrain == collider.gameObject)
                {
                    if (!terr.terrain.GetComponent <Collider2D>().OverlapPoint(terr.chain.transform.position))
                    {
                        terr.chain.transform.parent.SendMessage("OnMouseDown");
                        gGrootClass.terrainGrootChains.Remove(terr);
                        i--;
                    }
                }
            }
        }
    }
    public void LegacyUpgrade()
    {
        if (!IsLegacy)
        {
            return;
        }

                #if UNITY_EDITOR
        UnityEditor.Undo.RecordObject(gameObject, "Upgrade Ferr2D Terrain");
                #endif

        Ferr2D_Path oldPath = GetComponent <Ferr2D_Path>();
        MatchOverrides();

        // upgrade the path
        pathData        = new Ferr2DPath();
        pathData.Closed = oldPath.closed;
        for (int i = 0; i < oldPath.pathVerts.Count; i++)
        {
            int            next      = Ferr.PathUtil.WrapIndex(i - 1, Path.Count, Path.closed);
            Ferr.PointType pointType = Ferr.PointType.Sharp;
            if (smoothPath)
            {
                Ferr2DT_TerrainDirection prevSegmentDirection = Ferr2D_Path.GetDirection(Path.pathVerts, next, fill == Ferr2DT_FillMode.InvertedClosed, Path.closed, directionOverrides);
                Ferr2DT_TerrainDirection nextSegmentDirection = Ferr2D_Path.GetDirection(Path.pathVerts, i, fill == Ferr2DT_FillMode.InvertedClosed, Path.closed, directionOverrides);
                if (prevSegmentDirection == nextSegmentDirection)
                {
                    pointType = Ferr.PointType.Auto;
                }
            }

            Ferr2D_PointData data = new Ferr2D_PointData();
            data.scale             = vertScales[next];
            data.directionOverride = (int)directionOverrides[next];
            data.cutOverrides      = cutOverrides[next].data;
            pathData.Add(oldPath.pathVerts[i], data, pointType);
        }
        pathData.ReverseSelf();
        pathData.SetDirty();

        // remove old path values
        directionOverrides = null;
        cutOverrides       = null;
        vertScales         = null;

        // upgrade collider settings
        if (createCollider)
        {
            if (useEdgeCollider)
            {
                colliderMode = Ferr2D_ColliderMode.Edge2D;
            }
            else if (create3DCollider)
            {
                colliderMode = Ferr2D_ColliderMode.Mesh3D;
            }
            else
            {
                colliderMode = Ferr2D_ColliderMode.Polygon2D;
            }
        }
        else
        {
            colliderMode = Ferr2D_ColliderMode.None;
        }

        // upgrade the fill settings
        switch (fill)
        {
        case Ferr2DT_FillMode.None:
            edgeMode = Ferr2D_SectionMode.Normal;
            fillMode = Ferr2D_SectionMode.None; break;

        case Ferr2DT_FillMode.Closed:
            edgeMode = Ferr2D_SectionMode.Normal;
            fillMode = Ferr2D_SectionMode.Normal; break;

        case Ferr2DT_FillMode.InvertedClosed:
            edgeMode = Ferr2D_SectionMode.Invert;
            fillMode = Ferr2D_SectionMode.Invert; break;

        case Ferr2DT_FillMode.FillOnlyClosed:
            edgeMode = Ferr2D_SectionMode.None;
            fillMode = Ferr2D_SectionMode.Normal; break;

        case Ferr2DT_FillMode.Skirt:
            edgeMode = Ferr2D_SectionMode.Normal;
            fillMode = Ferr2D_SectionMode.Normal;
            useSkirt = true; break;

        case Ferr2DT_FillMode.FillOnlySkirt:
            edgeMode = Ferr2D_SectionMode.None;
            fillMode = Ferr2D_SectionMode.Normal;
            useSkirt = true; break;
        }

        isLegacy = false;

                #if UNITY_EDITOR
        UnityEditor.Undo.DestroyObjectImmediate(oldPath);
                #else
        Destroy(oldPath);
                #endif

        Build(true);

                #if UNITY_EDITOR
        UnityEditor.SceneView.RepaintAll();
                #endif
    }
    private void    DragSelect(Ferr2D_Path path)
    {
        if (Event.current.type == EventType.Repaint)
        {
            if (drag)
            {
                Vector3 pt1 = HandleUtility.GUIPointToWorldRay(dragStart).GetPoint(0.2f);
                Vector3 pt2 = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition).GetPoint(0.2f);
                Vector3 pt3 = HandleUtility.GUIPointToWorldRay(new Vector2(dragStart.x, Event.current.mousePosition.y)).GetPoint(0.2f);
                Vector3 pt4 = HandleUtility.GUIPointToWorldRay(new Vector2(Event.current.mousePosition.x, dragStart.y)).GetPoint(0.2f);
                Handles.DrawSolidRectangleWithOutline(new Vector3[] { pt1, pt3, pt2, pt4 }, new Color(0, 0.5f, 0.25f, 0.25f), new Color(0, 0.5f, 0.25f, 0.5f));
            }
        }

        if (Event.current.shift && Event.current.control)
        {
            switch (Event.current.type)
            {
            case EventType.MouseDrag:
                SceneView.RepaintAll();
                break;

            case EventType.MouseMove:
                SceneView.RepaintAll();
                break;

            case EventType.MouseDown:
                dragStart = Event.current.mousePosition;
                drag      = true;

                break;

            case EventType.MouseUp:
                Vector2 dragEnd = Event.current.mousePosition;
                selectedPoints.Clear();
                for (int i = 0; i < path.pathVerts.Count; i += 1)
                {
                    float left   = Mathf.Min(dragStart.x, dragStart.x + (dragEnd.x - dragStart.x));
                    float right  = Mathf.Max(dragStart.x, dragStart.x + (dragEnd.x - dragStart.x));
                    float top    = Mathf.Min(dragStart.y, dragStart.y + (dragEnd.y - dragStart.y));
                    float bottom = Mathf.Max(dragStart.y, dragStart.y + (dragEnd.y - dragStart.y));

                    Rect r = new Rect(left, top, right - left, bottom - top);
                    if (r.Contains(HandleUtility.WorldToGUIPoint(path.transform.TransformPoint(path.pathVerts[i]))))
                    {
                        selectedPoints.Add(i);
                    }
                }

                HandleUtility.AddDefaultControl(0);
                drag = false;
                Repaint();
                break;

            case EventType.Layout:
                HandleUtility.AddDefaultControl(GetHashCode());
                break;
            }
        }
        else if (drag == true)
        {
            drag = false;
            Repaint();
        }
    }
    private void LegacyAddVertexColumn(Ferr2DT_SegmentDescription aDesc, List <Vector2> aSegment, List <float> aSegmentScale, bool aClosed, Ferr2D_DynamicMesh mesh, Rect body, float d, float yOff, bool aConnectFace, float slicePercent, int ptLocal, float pctLocal, ref int p1, ref int p2, ref int p3)
    {
        Vector2 pos1 = smoothPath ? Ferr2D_Path.HermiteGetPt(aSegment, ptLocal, pctLocal, aClosed) : Ferr2D_Path.LinearGetPt(aSegment, ptLocal, pctLocal, aClosed);
        Vector2 n1   = smoothPath ? Ferr2D_Path.HermiteGetNormal(aSegment, ptLocal, pctLocal, aClosed) : Ferr2D_Path.LinearGetNormal(aSegment, ptLocal, pctLocal, aClosed);
        float   s    = aClosed    ? Mathf.Lerp(aSegmentScale[ptLocal], aSegmentScale[(ptLocal + 1) % aSegmentScale.Count], pctLocal) : Mathf.Lerp(aSegmentScale[ptLocal], aSegmentScale[Mathf.Min(ptLocal + 1, aSegmentScale.Count - 1)], pctLocal);

        // this compensates for scale distortion when corners are very sharp, but the normals are not long enough to keep the edge the appropriate width
        // not actually a problem for smooth paths
        if (!smoothPath)
        {
            n1.Normalize();
            float rootScale = 1f / Mathf.Abs(Mathf.Cos(Vector2.Angle(Ferr2D_Path.GetSegmentNormal(ptLocal, aSegment, aClosed), n1) * Mathf.Deg2Rad));
            s = s * rootScale;
        }

        int v1 = mesh.AddVertex(pos1.x + n1.x * (d * s + yOff), pos1.y + n1.y * (d * s + yOff), -slantAmount + aDesc.zOffset, Mathf.Lerp(body.x, body.xMax, slicePercent), fill == Ferr2DT_FillMode.InvertedClosed ? body.yMax : body.y);
        int v2 = mesh.AddVertex(pos1.x - n1.x * (d * s - yOff), pos1.y - n1.y * (d * s - yOff), slantAmount + aDesc.zOffset, Mathf.Lerp(body.x, body.xMax, slicePercent), fill == Ferr2DT_FillMode.InvertedClosed ? body.y : body.yMax);
        int v3 = splitMiddle ? mesh.AddVertex(pos1.x + n1.x * yOff, pos1.y + n1.y * yOff, aDesc.zOffset, Mathf.Lerp(body.x, body.xMax, slicePercent), Mathf.Lerp(body.y, body.yMax, 0.5f)) : -1;

        if (aConnectFace)
        {
            if (!splitMiddle)
            {
                mesh.AddFace(v2, p2, p1, v1);
            }
            else
            {
                mesh.AddFace(v2, p2, p3, v3);
                mesh.AddFace(v3, p3, p1, v1);
            }
        }

        p1 = v1;
        p2 = v2;
        p3 = v3;
    }
    private void    DoShiftAdd(Ferr2D_Path path, GUIStyle iconStyle)
    {
        Vector3             snap         = Event.current.control ? new Vector3(EditorPrefs.GetFloat("MoveSnapX"), EditorPrefs.GetFloat("MoveSnapY"), EditorPrefs.GetFloat("MoveSnapZ")) : Vector3.zero;
        Ferr2DT_PathTerrain terrain      = path.gameObject.GetComponent <Ferr2DT_PathTerrain>();
        Transform           transform    = path.transform;
        Transform           camTransform = SceneView.lastActiveSceneView.camera.transform;
        Vector3             pos          = transform.InverseTransformPoint(GetMousePos(Event.current.mousePosition, transform));
        bool hasDummy = path.pathVerts.Count <= 0;

        if (hasDummy)
        {
            path.pathVerts.Add(Vector2.zero);
        }

        int closestID = path.GetClosestSeg(pos);
        int secondID  = closestID + 1 >= path.Count ? 0 : closestID + 1;

        float firstDist  = Vector2.Distance(pos, path.pathVerts[closestID]);
        float secondDist = Vector2.Distance(pos, path.pathVerts[secondID]);

        Vector3 local = pos;

        if (Event.current.control && Ferr2DT_Menu.SnapMode == Ferr2DT_Menu.SnapType.SnapLocal)
        {
            local = SnapVector(local, snap);
        }
        Vector3 global = transform.TransformPoint(pos);

        if (Event.current.control && Ferr2DT_Menu.SnapMode == Ferr2DT_Menu.SnapType.SnapGlobal)
        {
            global = SnapVector(global, snap);
        }

        Handles.color = Color.white;
        if (!(secondID == 0 && !path.closed && firstDist > secondDist))
        {
            Handles.DrawLine(global, transform.TransformPoint(path.pathVerts[closestID]));
        }
        if (!(secondID == 0 && !path.closed && firstDist < secondDist))
        {
            Handles.DrawLine(global, transform.TransformPoint(path.pathVerts[secondID]));
        }
        Handles.color = new Color(1, 1, 1, 1);

        Vector3 handlePos = transform.TransformPoint(pos);
        float   scale     = HandleScale(handlePos);

        if (Handles.Button(handlePos, camTransform.rotation, scale, scale, CapDotPlus))
        {
            Vector3 finalPos = transform.InverseTransformPoint(global);
            if (secondID == 0)
            {
                if (firstDist < secondDist)
                {
                    if (terrain)
                    {
                        terrain.AddPoint(finalPos);
                    }
                    else
                    {
                        path.pathVerts.Add(finalPos);
                    }
                }
                else
                {
                    if (terrain)
                    {
                        terrain.AddPoint(finalPos, 0);
                    }
                    else
                    {
                        path.pathVerts.Insert(0, finalPos);
                    }
                }
            }
            else
            {
                if (terrain)
                {
                    terrain.AddPoint(finalPos, Mathf.Max(closestID, secondID));
                }
                else
                {
                    path.pathVerts.Insert(Mathf.Max(closestID, secondID), finalPos);
                }
            }
            selectedPoints.Clear();
            GUI.changed = true;
        }

        if (hasDummy)
        {
            path.pathVerts.RemoveAt(0);
        }
    }
예제 #41
0
    public override void OnInspectorGUI()
    {
        EditorTools.TitleField("地板編輯工具");
        Undo.RecordObject(target, "Modified Path");

        Ferr2D_Path path = (Ferr2D_Path)target;

        // if this was an undo, refresh stuff too
        if (Event.current.type == EventType.ValidateCommand)
        {
            switch (Event.current.commandName)
            {
            case "UndoRedoPerformed":

                path.UpdateDependants(true);
                if (OnChanged != null)
                {
                    OnChanged();
                }
                return;
            }
        }

        path.closed = EditorGUILayout.Toggle("封閉地面", path.closed);
        if (path)
        {
            // display the path verts list info
            showVerts = EditorGUILayout.Foldout(showVerts, "頂點座標");
        }
        EditorGUI.indentLevel = 2;
        if (showVerts)
        {
            int size = EditorGUILayout.IntField("數量: ", path.pathVerts.Count);
            while (path.pathVerts.Count > size)
            {
                path.pathVerts.RemoveAt(path.pathVerts.Count - 1);
            }
            while (path.pathVerts.Count < size)
            {
                path.pathVerts.Add(new Vector2(0, 0));
            }
        }
        // draw all the verts! Long list~
        for (int i = 0; showVerts && i < path.pathVerts.Count; i++)
        {
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.LabelField("#" + i, GUILayout.Width(60));
            path.pathVerts[i] = new Vector2(
                EditorGUILayout.FloatField(path.pathVerts[i].x),
                EditorGUILayout.FloatField(path.pathVerts[i].y));
            EditorGUILayout.EndHorizontal();
        }

        // button for updating the origin of the object

        if (GUILayout.Button("座標重置"))
        {
            path.ReCenter();
        }

        bool updateClosed           = false;
        Ferr2DT_PathTerrain terrain = path.GetComponent <Ferr2DT_PathTerrain>();

        if (!path.closed && terrain != null && (terrain.fill == Ferr2DT_FillMode.Closed || terrain.fill == Ferr2DT_FillMode.InvertedClosed || terrain.fill == Ferr2DT_FillMode.FillOnlyClosed))
        {
            path.closed  = true;
            updateClosed = true;
        }
        if (terrain != null && path.closed && (terrain.fill == Ferr2DT_FillMode.FillOnlySkirt || terrain.fill == Ferr2DT_FillMode.Skirt))
        {
            path.closed  = false;
            updateClosed = true;
        }

        // update dependants when it changes
        if (GUI.changed || updateClosed)
        {
            path.UpdateDependants(false);
            EditorUtility.SetDirty(target);
        }

        sizeX = EditorTools.IntField(sizeX, "寬");
        sizeY = EditorTools.IntField(sizeY, "長");

        if (GUILayout.Button("地板格式化"))
        {
            path.pathVerts = new List <Vector2>();
            path.pathVerts.Add(new Vector2(sizeX, sizeY) * 0.5F);
            path.pathVerts.Add(new Vector2(sizeX, -sizeY) * 0.5F);
            path.pathVerts.Add(new Vector2(-sizeX, -sizeY) * 0.5F);
            path.pathVerts.Add(new Vector2(-sizeX, sizeY) * 0.5F);
            UpdateDependentsSmart(path, false, false);
            EditorUtility.SetDirty(target);
            prevChanged = true;

            BoxCollider2D box2D = path.GetComponent <BoxCollider2D>();
            if (box2D)
            {
                path.GetComponent <BoxCollider2D>().size = new Vector2(sizeX, sizeY);
                EditorUtility.SetDirty(path.GetComponent <BoxCollider2D>());
            }
        }

        if (GUILayout.Button("進階地板設定"))
        {
            GroundBase groundBase = path.GetComponent <GroundBase>();
            if (!groundBase)
            {
                path.gameObject.AddComponent <GroundBase>();
            }
        }

        EditorTools.Mig();
    }
예제 #42
0
    private Ferr2DT_SegmentDescription  GetDescription(List <Vector2> aSegment)
    {
        Ferr2DT_TerrainDirection dir = Ferr2D_Path.GetDirection(aSegment, 0, fill == Ferr2DT_FillMode.InvertedClosed);

        return(terrainMaterial.GetDescriptor(dir));
    }
예제 #43
0
    void OnGUI()
    {
        radius      = EditorGUILayout.FloatField("Radius", radius);
        placeAround = (Transform)EditorGUILayout.ObjectField(placeAround, typeof(Transform), true);

        GUILayout.Label("Parent Transform for Points", EditorStyles.boldLabel);
        EditorGUILayout.BeginHorizontal();
        doTransform = EditorGUILayout.Toggle(doTransform, GUILayout.Width(14f));
        parentItem  = (Transform)EditorGUILayout.ObjectField(parentItem, typeof(Transform), true);
        EditorGUILayout.EndHorizontal();

        GUILayout.Label("EdgeCollider GameObject", EditorStyles.boldLabel);
        EditorGUILayout.BeginHorizontal();
        doEdgeCollider = EditorGUILayout.Toggle(doEdgeCollider, GUILayout.Width(14f));
        edgeCollider   = (EdgeCollider2D)EditorGUILayout.ObjectField(edgeCollider, typeof(EdgeCollider2D), true);
        EditorGUILayout.EndHorizontal();

        GUILayout.Label("Ferr2D terrain points", EditorStyles.boldLabel);
        EditorGUILayout.BeginHorizontal();
        doFerrTerrain = EditorGUILayout.Toggle(doFerrTerrain, GUILayout.Width(14f));
        path          = (Ferr2D_Path)EditorGUILayout.ObjectField(path, typeof(Ferr2D_Path), true);
        EditorGUILayout.EndHorizontal();


        if (GUI.Button(new Rect(3, 170, position.width - 6, 20), "Make a Circle"))
        {
            if (doTransform && parentItem)
            {
                Transform[] transforms = parentItem.GetComponentsInChildren <Transform>();
                Vector2[]   tempPoints = new Vector2[transforms.Length];

                int i = 0;
                foreach (Transform t in transforms)
                {
                    tempPoints[i].x = t.position.x;
                    tempPoints[i].y = t.position.y;

                    i++;
                }

                if (placeAround)
                {
                    PlacePointsInACircle(ref tempPoints, radius, placeAround.position);
                }
                else
                {
                    PlacePointsInACircle(ref tempPoints, radius, Vector2.zero);
                }

                i = 0;
                foreach (Vector2 p in tempPoints)
                {
                    transforms[i].position = new Vector3(p.x, p.y, 0f);
                    i++;
                }
            }
            if (doEdgeCollider && edgeCollider)
            {
                Vector2[] tempPoints = edgeCollider.points;

                if (placeAround)
                {
                    PlacePointsInACircle(ref tempPoints, radius, placeAround.position);
                }
                else
                {
                    PlacePointsInACircle(ref tempPoints, radius, Vector2.zero);
                }

                edgeCollider.points = tempPoints;
            }
            if (doFerrTerrain && path)
            {
                Vector2[] tempPoints = path.GetVertsRaw().ToArray();

                if (placeAround)
                {
                    PlacePointsInACircle(ref tempPoints, radius, placeAround.position, false);
                }
                else
                {
                    PlacePointsInACircle(ref tempPoints, radius, Vector2.zero, false);
                }

                path.pathVerts = new List <Vector2>(tempPoints);

                path.UpdateColliders();
                path.UpdateDependants(true);
            }
        }
    }
예제 #44
0
	private void    DragSelect           (Ferr2D_Path path) {
		
		if (Event.current.type == EventType.repaint) {
			if (drag) {
				Vector3 pt1 = HandleUtility.GUIPointToWorldRay(dragStart).GetPoint(0.2f);
				Vector3 pt2 = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition).GetPoint(0.2f);
				Vector3 pt3 = HandleUtility.GUIPointToWorldRay(new Vector2(dragStart.x, Event.current.mousePosition.y)).GetPoint(0.2f);
				Vector3 pt4 = HandleUtility.GUIPointToWorldRay(new Vector2(Event.current.mousePosition.x, dragStart.y)).GetPoint(0.2f);
				Handles.DrawSolidRectangleWithOutline(new Vector3[] { pt1, pt3, pt2, pt4 }, new Color(0, 0.5f, 0.25f, 0.25f), new Color(0, 0.5f, 0.25f, 0.5f));
			}
		}
		
		if (Event.current.shift && Event.current.control) {
			switch(Event.current.type) {
			case EventType.mouseDrag:
				SceneView.RepaintAll();
				break;
			case EventType.mouseMove:
				SceneView.RepaintAll();
				break;
			case EventType.mouseDown:
				dragStart = Event.current.mousePosition;
				drag = true;
				
				break;
			case EventType.mouseUp:
				Vector2 dragEnd = Event.current.mousePosition;
				selectedPoints.Clear();
				for	(int i=0;i<path.pathVerts.Count;i+=1) {
					float left   = Mathf.Min(dragStart.x, dragStart.x + (dragEnd.x - dragStart.x));
					float right  = Mathf.Max(dragStart.x, dragStart.x + (dragEnd.x - dragStart.x));
					float top    = Mathf.Min(dragStart.y, dragStart.y + (dragEnd.y - dragStart.y));
					float bottom = Mathf.Max(dragStart.y, dragStart.y + (dragEnd.y - dragStart.y));
					
					Rect r = new Rect(left, top, right-left, bottom-top);
					if (r.Contains(HandleUtility.WorldToGUIPoint(path.transform.TransformPoint( path.pathVerts[i]) ) )) {
						selectedPoints.Add(i);
					}
				}
				
				HandleUtility.AddDefaultControl(0);
				drag = false;
				Repaint();
				break;
			case EventType.layout :
				HandleUtility.AddDefaultControl(GetHashCode());
				break;
			}
		} else if (drag == true) {
			drag = false;
			Repaint();
		}
	}
예제 #45
0
	Mesh GetMesh() {
		MeshFilter filter  = GetComponent<MeshFilter>();
		string     newName = GetMeshName();
		Mesh       result  = filter.sharedMesh;
		
		if (IsPrefab()) {
#if UNITY_EDITOR
			if (filter.sharedMesh == null || filter.sharedMesh.name != newName) {
				string path      = UnityEditor.AssetDatabase.GetAssetPath(this) + "/Meshes/" + newName + ".asset";
				Mesh   assetMesh = UnityEditor.AssetDatabase.LoadAssetAtPath(path, typeof(Mesh)) as Mesh;
				if (assetMesh != null) { 
					result = assetMesh;
				} else {
					path = System.IO.Path.GetDirectoryName(UnityEditor.AssetDatabase.GetAssetPath(this)) + "/Meshes";
					string assetName = "/" + newName + ".asset";
					result = new Mesh();
					result.name = newName;
					
					if (!Directory.Exists(path)) {
						Directory.CreateDirectory(path);
					}
					try {
						UnityEditor.AssetDatabase.CreateAsset(result, path + assetName);
						UnityEditor.AssetDatabase.Refresh();
					} catch {
						Debug.LogError("Unable to save terrain prefab mesh! Likely, you deleted the mesh files, and the prefab is still referencing them. Restarting your Unity editor should solve this minor issue.");
					}
				}
			}
#endif
		} else {
			if (filter.sharedMesh == null || filter.sharedMesh.name != newName) {
				result = new Mesh();
			}
		}
		result.name = newName;
		return result;
	}
예제 #46
0
	private Vector3 GetTickerOffset      (Ferr2D_Path path, Vector3  aRootPos, int aIndex) {
		float   scale  = HandleScale(aRootPos) * 0.5f;
		Vector3 result = Vector3.zero;
		
		int     index  = (aIndex + 1) % path.pathVerts.Count;
		Vector3 delta  = Vector3.Normalize(path.pathVerts[index] - path.pathVerts[aIndex]);
		Vector3 norm   = new Vector3(-delta.y, delta.x, 0);
		result = delta * scale * 3 + new Vector3(norm.x, norm.y, 0) * scale * 2;

		return result;
	}
예제 #47
0
    private void                RecreateCollider2D()
    {
        List <Collider2D>      colliders = new List <Collider2D>(1);
        List <List <Vector2> > segs      = GetColliderVerts();
        bool closed = collidersBottom && collidersLeft && collidersRight && collidersTop;

        if (useEdgeCollider)
        {
            EdgeCollider2D[]      edges    = GetComponents <EdgeCollider2D>();
            List <EdgeCollider2D> edgePool = new List <EdgeCollider2D>(edges);
            int extra = edges.Length - segs.Count;

            if (extra > 0)
            {
                // we have too many, remove a few
                for (int i = 0; i < extra; i += 1)
                {
                    Destroy(edgePool[0]);
                    edgePool.RemoveAt(0);
                }
            }
            else
            {
                // we have too few, add in a few
                for (int i = 0; i < Mathf.Abs(extra); i += 1)
                {
                    edgePool.Add(gameObject.AddComponent <EdgeCollider2D>());
                }
            }

            for (int i = 0; i < segs.Count; i++)
            {
                EdgeCollider2D edge = edgePool[i];
                edge.points = segs[i].ToArray();
                colliders.Add(edge);
            }
        }
        else
        {
            // make sure there's a collider component on this object
            PolygonCollider2D poly = GetComponent <PolygonCollider2D>();
            if (poly == null)
            {
                poly = gameObject.AddComponent <PolygonCollider2D>();
            }
            colliders.Add(poly);

            poly.pathCount = segs.Count;
            if (segs.Count > 1 || !closed)
            {
                for (int i = 0; i < segs.Count; i++)
                {
                    poly.SetPath(i, ExpandColliderPath(segs[i], colliderThickness).ToArray());
                }
            }
            else
            {
                if (fill == Ferr2DT_FillMode.InvertedClosed)
                {
                    Rect bounds = Ferr2D_Path.GetBounds(segs[0]);
                    poly.pathCount = 2;
                    poly.SetPath(0, segs[0].ToArray());
                    poly.SetPath(1, new Vector2[] {
                        new Vector2(bounds.xMin - bounds.width, bounds.yMax + bounds.height),
                        new Vector2(bounds.xMax + bounds.width, bounds.yMax + bounds.height),
                        new Vector2(bounds.xMax + bounds.width, bounds.yMin - bounds.height),
                        new Vector2(bounds.xMin - bounds.width, bounds.yMin - bounds.height)
                    });
                }
                else
                {
                    if (segs.Count > 0 && segs[0].Count > 0)
                    {
                        poly.SetPath(0, segs[0].ToArray());
                    }
                }
            }
        }


        for (int i = 0; i < colliders.Count; i += 1)
        {
            colliders[i].isTrigger      = isTrigger;
            colliders[i].sharedMaterial = physicsMaterial2D;
                        #if UNITY_5
            colliders[i].usedByEffector = usedByEffector;
                        #endif
        }
    }
예제 #48
0
	private void    DoPath               (Ferr2D_Path path)
	{
		Handles.color = Color.white;
		List<Vector2> verts     = path.GetVertsRaw();
        Matrix4x4     mat       = path.transform.localToWorldMatrix;

		for (int i = 0; i < verts.Count - 1; i++)
		{
			Vector3 pos  = mat.MultiplyPoint3x4(verts[i]);
			Vector3 pos2 = mat.MultiplyPoint3x4(verts[i + 1]);
			Handles.DrawLine(pos, pos2);
		}
		if (path.closed)
		{
			Vector3 pos  = mat.MultiplyPoint3x4(verts[0]);
			Vector3 pos2 = mat.MultiplyPoint3x4(verts[verts.Count - 1]);
			Handles.DrawLine(pos, pos2);
		}
	}
예제 #49
0
    /// <summary>
    /// Retrieves a list of line segments that directly represent the collision volume of the terrain. This includes offsets and removed edges.
    /// </summary>
    /// <returns>A list of line segments.</returns>
    public List <List <Vector2> > GetColliderVerts()
    {
        List <Vector2> tVerts = Path.GetVertsRaw();

        // drop a skirt on skirt-based terrain
        if ((fill == Ferr2DT_FillMode.Skirt || fill == Ferr2DT_FillMode.FillOnlySkirt) && tVerts.Count > 0)
        {
            Vector2 start = tVerts[0];
            Vector2 end   = tVerts[tVerts.Count - 1];
            tVerts.Add(new Vector2(end.x, fillY));
            tVerts.Add(new Vector2(start.x, fillY));
            tVerts.Add(new Vector2(start.x, start.y));
        }

        float fillDist = (terrainMaterial.ToUV(terrainMaterial.GetBody((Ferr2DT_TerrainDirection)0, 0)).width *(terrainMaterial.edgeMaterial.mainTexture.width / pixelsPerUnit)) / (Mathf.Max(1, splitCount)) * splitDist;
        List <Ferr2DT_TerrainDirection> dirs   = new List <Ferr2DT_TerrainDirection>();
        List <List <Vector2> >          result = new List <List <Vector2>           >();
        List <List <int> > list = GetSegments(tVerts, out dirs);
        List <Vector2>     curr = new List <Vector2>();

        // remove segments that aren't on the terrain
        for (int i = 0; i < list.Count; i++)
        {
            if ((dirs[i] == Ferr2DT_TerrainDirection.Bottom && !collidersBottom) ||
                (dirs[i] == Ferr2DT_TerrainDirection.Left && !collidersLeft) ||
                (dirs[i] == Ferr2DT_TerrainDirection.Top && !collidersTop) ||
                (dirs[i] == Ferr2DT_TerrainDirection.Right && !collidersRight))
            {
                if (curr.Count > 0)
                {
                    result.Add(new List <Vector2>(curr));
                    curr.Clear(                       );
                }
            }
            else
            {
                // create a list of verts and scales for this edge
                List <float>   tScales = null;
                List <Vector2> tList   = null;
                Ferr2D_Path.IndicesToPath(tVerts, vertScales, list[i], out tList, out tScales);

                // smooth it!
                if (smoothPath && tList.Count > 2)
                {
                    Ferr2D_Path.SmoothSegment(tList, tScales, fillDist, false, out tList, out tScales);
                }

                // offset the verts based on scale and terrain edge info
                tList = OffsetColliderVerts(tList, tScales, dirs[i]);

                // sharpen corners properly!
                if (curr.Count > 0 && sharpCorners)
                {
                    MergeCorner(ref curr, ref tList);
                }

                curr.AddRange(tList);
            }
        }
        if (sharpCorners)
        {
            MergeCorner(ref curr, ref curr);
        }
        if (curr.Count > 0)
        {
            result.Add(curr);
        }

        return(result);
    }