Esempio n. 1
0
    Vector2 scrollPos; //keeps track of scroll bars position
    public override void OnInspectorGUI()
    {
        serializedObject.Update();
        CustomTerrain terrain = (CustomTerrain)target;

        EditorGUILayout.PropertyField(resetTerrain);

        /* //scrollbar UI code start
         * Rect r = EditorGUILayout.BeginVertical();
         * scrollPos = EditorGUILayout.BeginScrollView(scrollPos, GUILayout.Width(r.width), GUILayout.Height(r.height));
         * EditorGUI.indentLevel++; */

        //foldout terrain for random height
        showRandom = EditorGUILayout.Foldout(showRandom, "Random");
        if (showRandom)
        {
            EditorGUILayout.LabelField("", GUI.skin.horizontalSlider);
            GUILayout.Label("Set heights between random values", EditorStyles.boldLabel);
            EditorGUILayout.PropertyField(randomHeightRange);
            //on button click
            if (GUILayout.Button("Random heights"))
            {
                terrain.RandomTerrain();
            }
        }

        //foldout terrain editor for input image
        showPerlinNoise = EditorGUILayout.Foldout(showPerlinNoise, "Single Perlin Noise");
        if (showPerlinNoise)
        {
            EditorGUILayout.LabelField("", GUI.skin.horizontalSlider);
            GUILayout.Label("Perlin noisee", EditorStyles.boldLabel);
            EditorGUILayout.Slider(perlinXScale, 0, 0.1f, new GUIContent("X scale"));
            EditorGUILayout.Slider(perlinYScale, 0, 0.1f, new GUIContent("Y scale"));
            EditorGUILayout.IntSlider(perlinXOffset, 0, 10000, new GUIContent("X noise"));
            EditorGUILayout.IntSlider(perlinYOffset, 0, 10000, new GUIContent("Y noise"));
            EditorGUILayout.IntSlider(perlinOctaves, 1, 10, new GUIContent("Octaves"));
            EditorGUILayout.Slider(perlinPersistance, 0, 10f, new GUIContent("Persistance"));
            EditorGUILayout.Slider(perlinHeightScale, 0, 1f, new GUIContent("Height scale"));
            EditorGUILayout.Slider(freqMultiplier, 0, 5f, new GUIContent("frequency Multiplier"));
            //on button click
            if (GUILayout.Button("Perlin"))
            {
                terrain.Perlin();
            }
        }

        showMultiplePerlin = EditorGUILayout.Foldout(showMultiplePerlin, "Multiple Perlin Noise");
        if (showMultiplePerlin)
        {
            EditorGUILayout.LabelField("", GUI.skin.horizontalSlider);
            GUILayout.Label("Multiple Perlin Noise", EditorStyles.boldLabel);
            perlinParameterTable = GUITableLayout.DrawTable(perlinParameterTable, perlinParameters);
            GUILayout.Space(20); //formatting space so buttons dont appear on slider
            //this makes the plus and minus button next to each other horizontally on the gui
            EditorGUILayout.BeginHorizontal();
            if (GUILayout.Button("+"))
            {
                terrain.AddNewPerlin();
            }
            if (GUILayout.Button("-"))
            {
                terrain.RemovePerlin();
            }

            EditorGUILayout.EndHorizontal();

            if (GUILayout.Button("Apply Multiple Perlin"))
            {
                terrain.MultiplePerlinTerrain();
            }
        }
        showLoadHeights = EditorGUILayout.Foldout(showLoadHeights, "Load Height Map in");
        if (showLoadHeights)
        {
            EditorGUILayout.LabelField("", GUI.skin.horizontalSlider);
            GUILayout.Label("Set heights from input image", EditorStyles.boldLabel);
            EditorGUILayout.PropertyField(heightMapImage);
            EditorGUILayout.PropertyField(heightMapScale);
            //on button click
            if (GUILayout.Button("Load Texture"))
            {
                terrain.LoadTexture();
            }
        }
        showVoronoi = EditorGUILayout.Foldout(showVoronoi, "Voronoi");
        if (showVoronoi)
        {
            EditorGUILayout.IntSlider(voronoiPeaks, 1, 10, new GUIContent("Peak count"));
            EditorGUILayout.Slider(voronoiFallOff, 0, 10, new GUIContent("FallOff"));
            EditorGUILayout.Slider(voronoiDropOff, 0, 10, new GUIContent("Dropoff"));
            EditorGUILayout.Slider(voronoiMaxHeight, 0, 1, new GUIContent("Max Height"));
            EditorGUILayout.Slider(voronoiMinHeight, 0, 1, new GUIContent("Min Height"));
            EditorGUILayout.PropertyField(voronoiType);
            if (GUILayout.Button("Generate peaks"))
            {
                terrain.Voronoi();
            }
        }

        showMidpointDisplacement = EditorGUILayout.Foldout(showMidpointDisplacement, "Midpoint Displacement");
        if (showMidpointDisplacement)
        {
            if (GUILayout.Button("MP displacement"))
            {
                terrain.MidpointDisplacement();
            }
        }
        showSmooth = EditorGUILayout.Foldout(showSmooth, "Smooth");
        if (showSmooth)
        {
            EditorGUILayout.IntSlider(smoothAmount, 1, 10, new GUIContent("Smooth iterations"));
            if (GUILayout.Button("Smooth"))
            {
                terrain.Smooth();
            }
        }

        showSplatMaps = EditorGUILayout.Foldout(showSplatMaps, "Splat Maps");
        if (showSplatMaps)
        {
            EditorGUILayout.LabelField("", GUI.skin.horizontalSlider);
            GUILayout.Label("Splat Maps", EditorStyles.boldLabel);
            splatMapTable = GUITableLayout.DrawTable(splatMapTable, serializedObject.FindProperty("splatHeights"));
            GUILayout.Space(20);
            EditorGUILayout.BeginHorizontal();
            if (GUILayout.Button("+"))
            {
                terrain.AddSplatHeight();
            }
            if (GUILayout.Button("-"))
            {
                terrain.RemoveSplatHeight();
            }
            EditorGUILayout.EndHorizontal();

            if (GUILayout.Button("Apply Splatmaps"))
            {
                terrain.SplatMaps();
            }
        }
        showTrees = EditorGUILayout.Foldout(showTrees, "show Trees");
        if (showTrees)
        {
            EditorGUILayout.LabelField("", GUI.skin.horizontalSlider);
            GUILayout.Label("show Trees", EditorStyles.boldLabel);
            EditorGUILayout.IntSlider(maxTrees, 0, 10000, new GUIContent("Max Trees"));
            EditorGUILayout.IntSlider(treeSpacing, 2, 20, new GUIContent("Tree Spacing"));
            vegetation = GUITableLayout.DrawTable(vegetation, serializedObject.FindProperty("vegetation"));
            GUILayout.Space(20);
            EditorGUILayout.BeginHorizontal();
            if (GUILayout.Button("+"))
            {
                terrain.AddVegetation();
            }
            if (GUILayout.Button("-"))
            {
                terrain.RemoveVegetation();
            }
            EditorGUILayout.EndHorizontal();

            if (GUILayout.Button("Apply trees"))
            {
                terrain.PlantVegetation();
            }
        }

        showDetail = EditorGUILayout.Foldout(showDetail, "Detail");
        if (showDetail)
        {
            EditorGUILayout.LabelField("", GUI.skin.horizontalSlider);
            GUILayout.Label("Detail", EditorStyles.boldLabel);
            EditorGUILayout.IntSlider(maxDetails, 0, 10000, new GUIContent("Maximum Details"));
            EditorGUILayout.IntSlider(detailSpacing, 1, 20, new GUIContent("Detail Spacing"));
            //this line is broken even copy and pasted,,
            detailMapTable = GUITableLayout.DrawTable(detailMapTable,
                                                      serializedObject.FindProperty("details"));
            //sets the view distance of the details to the amount of objects so you can see all of them
            terrain.GetComponent <Terrain>().detailObjectDistance = maxDetails.intValue;

            GUILayout.Space(20);
            EditorGUILayout.BeginHorizontal();
            if (GUILayout.Button("+"))
            {
                terrain.AddDetail();
            }
            if (GUILayout.Button("-"))
            {
                terrain.RemoveDetail();
            }
            EditorGUILayout.EndHorizontal();
            if (GUILayout.Button("Apply Details"))
            {
                terrain.SpawnDetails();
            }
        }
        showErosion = EditorGUILayout.Foldout(showErosion, "Erosion");
        if (showErosion)
        {
            EditorGUILayout.LabelField("", GUI.skin.horizontalSlider);
            GUILayout.Label("Erosion", EditorStyles.boldLabel);
            EditorGUILayout.PropertyField(erosionType);
            EditorGUILayout.IntSlider(erosionSmoothAmount, 0, 10, new GUIContent("Smooth AMount"));
            EditorGUILayout.Slider(erosionStrength, 0.01f, 1, new GUIContent("Erosion strength"));
            EditorGUILayout.IntSlider(springsPerDroplet, 0, 60, new GUIContent("Spring/droplet"));
            EditorGUILayout.Slider(solubility, 0, 1, new GUIContent("Solubility"));
            EditorGUILayout.IntSlider(droplets, 1, 10000, new GUIContent("Droplets"));
            EditorGUILayout.Slider(thermalStrength, 0, 1, new GUIContent("ThermalStrength"));


            if (GUILayout.Button("Erode"))
            {
                terrain.Erode();
            }
        }
        //reset button seperate
        EditorGUILayout.LabelField("", GUI.skin.horizontalSlider);
        if (GUILayout.Button("Reset Terrain"))
        {
            terrain.ResetTerrain();
        }

        /*//scrollbar code END
         * EditorGUILayout.EndScrollView();
         * EditorGUILayout.EndVertical();
         */
        serializedObject.ApplyModifiedProperties();
    }
Esempio n. 2
0
    //The GUI Loop, it gets update
    public override void OnInspectorGUI()
    {
        serializedObject.Update();                     //Begin

        CustomTerrain terrain = (CustomTerrain)target; //Reference for our SCRIPT

        //CheckBox For resetTerrain
        EditorGUILayout.PropertyField(resetTerrainCheckBox);

        //Foldout on GUI
        showRandom = EditorGUILayout.Foldout(showRandom, "Random Heights");
        if (showRandom)//A foldout need to be followed by a if statement
        {
            EditorGUILayout.LabelField("", GUI.skin.horizontalSlider);
            GUILayout.Label("Set Heights Between Random Values", EditorStyles.boldLabel);
            EditorGUILayout.PropertyField(randomHeightRange); //!! link GUI values to our variable
            if (GUILayout.Button("Random Heights"))
            {
                terrain.RandomTerrain();//Method from our customTerrain Script to update our terrain.
            }
        }

        //Foldout PerlinNoise
        showPerlinNoise = EditorGUILayout.Foldout(showPerlinNoise, "Generate Perlin Noise");
        if (showPerlinNoise)//A foldout need to be followed by a if statement
        {
            EditorGUILayout.LabelField("", GUI.skin.horizontalSlider);
            GUILayout.Label("Randomize a new Perlin Noise", EditorStyles.boldLabel);
            EditorGUILayout.Slider(perlinXScale, 0, 1, new GUIContent("X Scale"));//value,min,max
            EditorGUILayout.Slider(perlinYScale, 0, 1, new GUIContent("Y Scale"));
            EditorGUILayout.IntSlider(perlinOffsetX, 0, 10000, new GUIContent("X OffSet"));
            EditorGUILayout.IntSlider(perlinOffsetY, 0, 10000, new GUIContent("Y OffSet"));
            EditorGUILayout.IntSlider(perlinOctaves, 0, 10, new GUIContent("Octaves"));
            EditorGUILayout.Slider(perlinPersistence, 0.1f, 10, new GUIContent("Persistence"));
            EditorGUILayout.Slider(perlinHeightScale, 0, 1, new GUIContent("Height Scale"));
            if (GUILayout.Button("Generate Perlin"))
            {
                terrain.perlin();
            }
        }

        //Foldout MultiplePerlinNoise
        showMultiplePerlins = EditorGUILayout.Foldout(showMultiplePerlins, "Generate Multiple Perlin");
        if (showMultiplePerlins)
        {
            EditorGUILayout.LabelField("", GUI.skin.horizontalSlider);
            GUILayout.Label("Multiple Perlin Noise", EditorStyles.boldLabel);
            perlinParametersTable = GUITableLayout.DrawTable(perlinParametersTable,
                                                             serializedObject.FindProperty("perlinParameters"));
            GUILayout.Space(20);
            EditorGUILayout.BeginHorizontal();
            if (GUILayout.Button("+"))
            {
                terrain.addNewPerlin();
            }
            if (GUILayout.Button("-"))
            {
                terrain.removeNewPerlin();
            }
            EditorGUILayout.EndHorizontal();
            if (GUILayout.Button("Apply Multiple Perlin"))
            {
                terrain.MultiplePerlin();
            }
        }


        //Foldout to HeightMap
        showLoadHeights = EditorGUILayout.Foldout(showLoadHeights, "Load Heights");
        if (showLoadHeights)//A foldout need to be followed by a if statement
        {
            EditorGUILayout.LabelField("", GUI.skin.horizontalSlider);
            GUILayout.Label("Load Heights From Texture", EditorStyles.boldLabel);
            EditorGUILayout.PropertyField(heightMapImage);
            EditorGUILayout.PropertyField(heightMapScale);
            if (GUILayout.Button("Load Texture"))
            {
                terrain.LoadTexture();
            }
        }

        //Voronoi
        showVoronoi = EditorGUILayout.Foldout(showVoronoi, "Voronoi");
        if (showVoronoi)
        {
            GUILayout.Label("Generate Voronoi Peaks", EditorStyles.boldLabel);
            EditorGUILayout.IntSlider(VoronoiPeakCount, 1, 10, new GUIContent("Peak count"));
            EditorGUILayout.Slider(VoronoiFallOff, 0.1f, 10, new GUIContent("Falloff"));
            EditorGUILayout.Slider(VoronoiDropOff, 0.1f, 10, new GUIContent("DropOff"));
            EditorGUILayout.Slider(VoronoiminHeight, 0.0f, 1f, new GUIContent("Min Height"));
            EditorGUILayout.Slider(VoronoiMaxHeight, 0.0f, 1f, new GUIContent("Max Height"));
            EditorGUILayout.PropertyField(VoronoiType);
            if (GUILayout.Button("Voronoi"))
            {
                terrain.voronoi();
            }
        }

        //MPD
        showMPD = EditorGUILayout.Foldout(showMPD, "Midpoint Displacement");
        if (showMPD)
        {
            EditorGUILayout.Slider(MPDminHeight, -10, 10, new GUIContent("Min Height"));
            EditorGUILayout.Slider(MPDmaxHeight, -10f, 10f, new GUIContent("Max Height"));
            EditorGUILayout.Slider(MPDRoughness, 0f, 100, new GUIContent("Roughness"));
            EditorGUILayout.Slider(MPDHeightDampener, 0f, 10, new GUIContent("Dampener"));
            if (GUILayout.Button("MPD"))
            {
                terrain.midPointDisplacement();
            }
        }

        //SplatMaps
        showSplatMaps = EditorGUILayout.Foldout(showSplatMaps, "Splat Maps");
        if (showSplatMaps)
        {
            EditorGUILayout.LabelField("", GUI.skin.horizontalSlider);
            GUILayout.Label("Splat Maps", EditorStyles.boldLabel);
            GUILayout.Space(10);
            splatMapTable = GUITableLayout.DrawTable(splatMapTable,
                                                     serializedObject.FindProperty("splatHeightsList"));
            GUILayout.Space(20);
            EditorGUILayout.BeginHorizontal();
            if (GUILayout.Button("+"))
            {
                terrain.AddNewSplatHeight();
            }
            if (GUILayout.Button("-"))
            {
                terrain.RemoveSplatHeight();
            }
            EditorGUILayout.EndHorizontal();
            if (GUILayout.Button("Apply SplatMaps"))
            {
                terrain.SplatMaps();
            }
            GUILayout.Space(20);
        }

        showVegetation = EditorGUILayout.Foldout(showVegetation, "Vegetation");
        if (showVegetation)
        {
            EditorGUILayout.LabelField("", GUI.skin.horizontalSlider);
            GUILayout.Label("Configure Vegetation", EditorStyles.boldLabel);
            GUILayout.Space(10);
            EditorGUILayout.IntSlider(maximumTrees, 1, 10000, new GUIContent("Maximum Trees"));
            EditorGUILayout.IntSlider(treeSpacing, 1, 25, new GUIContent("Trees Spacing"));
            GUILayout.Space(10);
            vegetations = GUITableLayout.DrawTable(vegetations,
                                                   serializedObject.FindProperty("vegetations"));
            GUILayout.Space(20);
            EditorGUILayout.BeginHorizontal();
            if (GUILayout.Button("+"))
            {
                terrain.AddVegetation();
            }
            if (GUILayout.Button("-"))
            {
                terrain.RemoveVegetation();
            }
            EditorGUILayout.EndHorizontal();
            if (GUILayout.Button("Apply Vegetation"))
            {
                terrain.applyVegetation();
            }
        }

        //Details
        showDetail = EditorGUILayout.Foldout(showDetail, "Details");
        if (showDetail)
        {
            EditorGUILayout.LabelField("", GUI.skin.horizontalSlider);
            GUILayout.Label("Detail", EditorStyles.boldLabel);
            EditorGUILayout.IntSlider(maxDetails, 0, 10000, new GUIContent("Maximum Details"));
            EditorGUILayout.IntSlider(detailSpacing, 1, 20, new GUIContent("Detail Spacing"));
            detailMapTable = GUITableLayout.DrawTable(detailMapTable,
                                                      serializedObject.FindProperty("details"));

            terrain.GetComponent <Terrain>().detailObjectDistance = maxDetails.intValue;

            GUILayout.Space(20);

            EditorGUILayout.BeginHorizontal();

            if (GUILayout.Button("+"))
            {
                terrain.AddNewDetails();
            }
            if (GUILayout.Button("-"))
            {
                terrain.RemoveDetails();
            }

            EditorGUILayout.EndHorizontal();
            if (GUILayout.Button("Apply Details"))
            {
                terrain.AddDetails();
            }
        }

        showWater = EditorGUILayout.Foldout(showWater, "Water");
        if (showWater)
        {
            EditorGUILayout.LabelField("", GUI.skin.horizontalSlider);
            GUILayout.Label("Water", EditorStyles.boldLabel);
            EditorGUILayout.Slider(waterHeight, 0, 1, new GUIContent("Water Height"));
            EditorGUILayout.PropertyField(waterGO);

            if (GUILayout.Button("Add Water"))
            {
                terrain.AddWater();
            }

            EditorGUILayout.PropertyField(shoreLineMaterial);
            if (GUILayout.Button("Add Shoreline"))
            {
                terrain.DrawShoreline();
            }
        }

        //Erosion
        showErosion = EditorGUILayout.Foldout(showErosion, "Erosion");
        if (showErosion)
        {
            EditorGUILayout.PropertyField(erosionType);
            EditorGUILayout.Slider(erosionStrength, 0f, 1f, new GUIContent("Erosion Strength"));
            EditorGUILayout.IntSlider(droplets, 0, 500, new GUIContent("Droplets Count"));
            EditorGUILayout.Slider(solubility, 0.001f, 1f, new GUIContent("Solubility"));
            EditorGUILayout.IntSlider(springsPerRiver, 0, 20, new GUIContent("Springs Per River"));
            EditorGUILayout.IntSlider(erosionSmoothAmount, 0, 10, new GUIContent("Smooth Amount"));
            EditorGUILayout.Slider(erosionAmount, 0.001f, 1f, new GUIContent("Erosion Amount"));
            if (GUILayout.Button("Erode"))
            {
                terrain.Erode();
            }
        }


        //SmoothButton
        showSmooth = EditorGUILayout.Foldout(showSmooth, "Smooth");
        if (showSmooth)
        {
            EditorGUILayout.PropertyField(smoothAmount);
            if (GUILayout.Button("Smooth"))
            {
                terrain.Smooth();
            }
        }

        //resetButton
        EditorGUILayout.LabelField("", GUI.skin.horizontalSlider);
        if (GUILayout.Button("Reset Terrain"))
        {
            terrain.resetTerrain();
        }


        //Height Map
        showHeightMap = EditorGUILayout.Foldout(showHeightMap, "Height Map");
        if (showHeightMap)
        {
            GUILayout.BeginHorizontal();
            GUILayout.FlexibleSpace();
            int hmtSize = (int)(EditorGUIUtility.currentViewWidth - 100);
            GUILayout.Label(hmTexture, GUILayout.Width(hmtSize), GUILayout.Height(hmtSize));
            GUILayout.FlexibleSpace();
            GUILayout.EndHorizontal();
            GUILayout.BeginHorizontal();
            GUILayout.FlexibleSpace();
            if (GUILayout.Button("Refresh", GUILayout.Width(hmtSize)))
            {
                float[,] heightMap = terrain.terrainData.GetHeights(0, 0,
                                                                    terrain.terrainData.heightmapWidth,
                                                                    terrain.terrainData.heightmapHeight);
                for (int y = 0; y < terrain.terrainData.heightmapWidth; y++)
                {
                    for (int x = 0; x < terrain.terrainData.heightmapHeight; x++)
                    {
                        hmTexture.SetPixel(x, y, new Color(heightMap[x, y],
                                                           heightMap[x, y],
                                                           heightMap[x, y], 1));
                    }
                }
                hmTexture.Apply();
            }
            GUILayout.FlexibleSpace();
            GUILayout.EndHorizontal();

            GUILayout.BeginHorizontal();
            GUILayout.FlexibleSpace();

            if (GUILayout.Button("Save", GUILayout.Width(hmtSize)))
            {
                byte[] bytes = hmTexture.EncodeToPNG();
                System.IO.Directory.CreateDirectory(Application.dataPath + "/SavedTextures");
                File.WriteAllBytes(Application.dataPath + "/SavedTextures/" + "MyTexture" + ".png", bytes);
            }
            GUILayout.FlexibleSpace();
            GUILayout.EndHorizontal();
        }

        serializedObject.ApplyModifiedProperties(); // END
    }