void ShowDirection(IFerr2DTMaterial aMat, int aDir)
    {
        Ferr2DT_SegmentDescription desc = aMat.GetDescriptor((Ferr2DT_TerrainDirection)aDir);

        settingsScroll = EditorGUILayout.BeginScrollView(settingsScroll);
        EditorGUILayout.LabelField("Edge Placement", EditorStyles.boldLabel);
        EditorGUI.indentLevel = 1;
        desc.zOffset          = EditorGUILayout.IntField("Draw Order", Mathf.RoundToInt(desc.zOffset * 1000)) / 1000f;
        desc.YOffsetPercent   = EditorGUILayout.Slider("Y Offset", desc.YOffsetPercent, -.5f, .5f);
        desc.yOffset          = EditorGUILayout.FloatField("[Legacy] Y Offset", desc.yOffset);
        desc.capOffset        = EditorGUILayout.FloatField("[Legacy] Cap Offset", desc.capOffset);
        EditorGUI.indentLevel = 0;

        Ferr2DT_TerrainMaterialUtility.EditColliders(desc);

        EditorGUILayout.Space();
        EditorGUILayout.LabelField("Edge Segments", EditorStyles.boldLabel);
        simpleUVs = EditorGUILayout.Toggle("Simple Mode", simpleUVs);
        if (simpleUVs)
        {
            Ferr2DT_TerrainMaterialUtility.EditUVsSimple(aMat, desc);
        }
        else
        {
            Ferr2DT_TerrainMaterialUtility.EditUVsComplex(aMat, desc, width, ref currBody);
        }
        EditorGUILayout.EndScrollView();
    }
    public override void OnInspectorGUI()
    {
        Undo.RecordObject(target, "Modified Terrain Material");

        IFerr2DTMaterial mat = target as IFerr2DTMaterial;
        Material         newMat;

        newMat = mat.edgeMaterial = (Material)EditorGUILayout.ObjectField("Edge Material", mat.edgeMaterial, typeof(Material), true);
        if (mat.edgeMaterial != newMat)
        {
            mat.edgeMaterial = newMat;
            Ferr2DT_TerrainMaterialUtility.CheckMaterialMode(mat.edgeMaterial, TextureWrapMode.Clamp);
        }

        newMat = (Material)EditorGUILayout.ObjectField("Fill Material", mat.fillMaterial, typeof(Material), true);
        if (mat.fillMaterial != newMat)
        {
            mat.fillMaterial = newMat;
            Ferr2DT_TerrainMaterialUtility.CheckMaterialMode(mat.fillMaterial, TextureWrapMode.Repeat);
        }

        if (mat.edgeMaterial == null)
        {
            EditorGUILayout.HelpBox("Please add an edge material to enable the material editor!", MessageType.Warning);
        }
        else
        {
            if (GUILayout.Button("Open Material Editor"))
            {
                Ferr2DT_TerrainMaterialWindow.Show(mat);
            }
        }

        DrawUpdateUI();

        if (GUI.changed)
        {
            EditorUtility.SetDirty(target);

            Ferr2DT_PathTerrain[] terrain = GameObject.FindObjectsOfType(typeof(Ferr2DT_PathTerrain)) as Ferr2DT_PathTerrain[];
            for (int i = 0; i < terrain.Length; i++)
            {
                if (terrain[i].TerrainMaterial == mat)
                {
                    terrain[i].Build(true);
                }
            }
        }
    }
Esempio n. 3
0
    public override void OnInspectorGUI()
    {
                #if !(UNITY_4_2 || UNITY_4_1 || UNITY_4_1 || UNITY_4_0 || UNITY_3_5 || UNITY_3_4 || UNITY_3_3 || UNITY_3_1 || UNITY_3_0)
        Undo.RecordObject(target, "Modified Terrain Material");
                #else
        Undo.SetSnapshotTarget(target, "Modified Terrain Material");
                #endif

        Ferr2DT_TerrainMaterial mat = target as Ferr2DT_TerrainMaterial;

        mat.edgeMaterial = (Material)EditorGUILayout.ObjectField("Edge Material", mat.edgeMaterial, typeof(Material), true);
        Material newMat = (Material)EditorGUILayout.ObjectField("Fill Material", mat.fillMaterial, typeof(Material), true);
        if (mat.fillMaterial != newMat)
        {
            mat.fillMaterial = newMat;
            Ferr2DT_TerrainMaterialUtility.CheckMaterialRepeat(mat.fillMaterial);
        }
        if (mat.edgeMaterial == null)
        {
            EditorGUILayout.HelpBox("Please add an edge material to enable the material editor!", MessageType.Warning);
        }
        else
        {
            if (GUILayout.Button("Open Material Editor"))
            {
                Ferr2DT_TerrainMaterialWindow.Show(mat);
            }
        }
        if (GUI.changed)
        {
            EditorUtility.SetDirty(target);

            Ferr2DT_PathTerrain[] terrain = GameObject.FindObjectsOfType(typeof(Ferr2DT_PathTerrain)) as Ferr2DT_PathTerrain[];
            for (int i = 0; i < terrain.Length; i++)
            {
                if (terrain[i].TerrainMaterial == mat)
                {
                    terrain[i].RecreatePath(true);
                }
            }
        }
    }
    void OnGUI()
    {
        if (_selectedMaterial == null)
        {
            return;
        }

        // if this was an undo, repaint it
        if (Event.current.type == EventType.ValidateCommand)
        {
            switch (Event.current.commandName)
            {
            case "UndoRedoPerformed":
                GUI.changed = true;
                Repaint();
                break;
            }
        }

        Undo.RecordObject((UnityEngine.Object)material, "Modified Terrain Material");

        if (Ferr.EditorTools.ResetHandles())
        {
            GUI.changed = true;
        }

        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.BeginVertical(GUILayout.Width(width));
        GUI.Box(new Rect(0, 0, width, position.height), GUIContent.none);

        bool          delete   = false;
        List <string> segments = new List <string>();

        for (int i = 0; i < material.descriptorCount; i++)
        {
            if (i == 0)
            {
                segments.Add("Top");
            }
            else if (i == 1)
            {
                segments.Add("Left");
            }
            else if (i == 2)
            {
                segments.Add("Right");
            }
            else if (i == 3)
            {
                segments.Add("Bottom");
            }
            else
            {
                segments.Add((i - 3).ToString());
            }
        }
        segments.Add("+New edge");

        currDir = EditorGUILayout.Popup(currDir, segments.ToArray());
        // new edge was selected!
        if (currDir == segments.Count - 1)
        {
            segments.Insert(segments.Count - 1, currDir.ToString());
            material.Add();
        }

        if (currDir != (int)Ferr2DT_TerrainDirection.None)
        {
            Ferr2DT_TerrainMaterialUtility.ShowSample(material, (Ferr2DT_TerrainDirection)currDir, width - 10);
        }

        if (prevDir != currDir)
        {
            simpleUVs = Ferr2DT_TerrainMaterialUtility.IsSimple(material.GetDescriptor((Ferr2DT_TerrainDirection)currDir));
        }
        EditorGUILayout.BeginHorizontal();
        bool show = GUILayout.Toggle(material.Has((Ferr2DT_TerrainDirection)currDir), "Use " + segments[currDir]);

        delete = GUILayout.Button("Delete");
        EditorGUILayout.EndHorizontal();
        material.Set((Ferr2DT_TerrainDirection)currDir, show);
        if (show)
        {
            ShowDirection(material, (int)currDir);
        }

        EditorGUILayout.EndVertical();
        EditorGUILayout.BeginVertical();
        scroll = EditorGUILayout.BeginScrollView(scroll);
        if (currDir != (int)Ferr2DT_TerrainDirection.None)
        {
            Ferr2DT_TerrainMaterialUtility.ShowPreview(material, (Ferr2DT_TerrainDirection)currDir, simpleUVs, true, width);
        }
        EditorGUILayout.EndScrollView();
        EditorGUILayout.EndVertical();
        EditorGUILayout.EndHorizontal();

        if (Event.current.type == EventType.MouseMove || Event.current.type == EventType.MouseDrag)
        {
            Repaint();
        }

        if (GUI.changed)
        {
            Ferr2DT_PathTerrainEditor.cachedColliders = null;
            EditorUtility.SetDirty((UnityEngine.Object)material);

            bool updatedTerrain           = false;
            Ferr2DT_PathTerrain[] terrain = GameObject.FindObjectsOfType(typeof(Ferr2DT_PathTerrain)) as Ferr2DT_PathTerrain[];
            for (int i = 0; i < terrain.Length; i++)
            {
                if (terrain[i].TerrainMaterial == material)
                {
                    terrain[i].Build(true);
                    updatedTerrain = true;
                }
            }

            if (updatedTerrain && !Application.isPlaying)
            {
                EditorSceneManager.MarkAllScenesDirty();
            }
        }

        prevDir = currDir;
        if (delete)
        {
            material.Remove((Ferr2DT_TerrainDirection)currDir);
            if (currDir > 3)
            {
                currDir -= 1;
            }
        }
    }