Create Custom Unity Editor UI

Oct 31, 2025 by Admin 30 views

Hey guys! Today, we're diving deep into the world of Unity editor scripting to build a parameterised custom editor window. This tool will allow us to procedurally generate building layouts right within the Unity editor. Think of it as your own personal building architect, accessible at the click of a button. We'll be focusing on creating a user-friendly interface (UI) that exposes various parameters, allowing for real-time adjustments and creative exploration. So, buckle up, and let's get started!

Why Build a Custom Editor Window?

Before we jump into the how-to, let’s address the why. Why bother creating a custom editor window when you can manually create buildings? Well, there are several compelling reasons:

Efficiency: Manually placing and configuring hundreds of rooms, corridors, and stairs is incredibly time-consuming. A procedural system automates this process, freeing you to focus on high-level design and iteration.
Consistency: Ensuring consistent style, room sizes, and corridor widths across an entire building can be challenging when done manually. A parameterised system enforces consistency, leading to a more polished and professional result.
Experimentation: A custom editor window makes it easy to experiment with different building layouts, styles, and configurations. You can quickly tweak parameters and see the results in real-time, fostering creativity and exploration.
Reusability: Once you've built your custom editor window, you can reuse it across multiple projects. This saves you time and effort in the long run.
Team Collaboration: A well-designed custom editor window can make it easier for team members to collaborate on building design. It provides a clear and consistent interface for everyone to use.

In essence, building a custom editor window is about optimizing your workflow, enhancing creativity, and achieving a higher level of control over your building design process. It transforms the tedious task of manual placement into an interactive and enjoyable experience. This means that using the right tools like this is important for level design and the overall production of your project.

Defining the Parameters

Our custom editor window will expose a set of parameters that control various aspects of the building generation process. These parameters will allow us to fine-tune the building's footprint, number of floors, room arrangements, and overall style. Here’s a breakdown of the key parameters we’ll be working with:

Footprint (Width x Height): This defines the overall size and shape of the building's base. We'll allow the user to specify the width and height in Unity units.
Floors: This determines the number of floors in the building. More floors means a taller building, opening up new possibilities for vertical gameplay and architectural design.
Rooms/Floor: This controls the number of rooms on each floor. A higher number of rooms can create a more complex and intricate layout. You can think of how this adds depth to the building interior.
Room-Type Mix: This allows the user to specify the proportion of different room types (e.g., offices, bedrooms, kitchens) on each floor. This adds variety and realism to the building's interior. Creating a good room-type mix helps in making the building believable and immersive.
Corridor Width: This defines the width of the corridors connecting the rooms. A wider corridor can create a more spacious and inviting feel.
Stair-Core Position: This determines the location of the stair core, which is the central area containing the stairs that connect the floors. The stair-core position can significantly impact the flow of the building, affecting navigation and accessibility.
Style Preset: This allows the user to select from a set of pre-defined style presets that control the overall look and feel of the building. Style presets can include things like wall textures, floor materials, and lighting schemes. Using Style Preset drastically cuts down production time and keeps things uniform.
Random Seed: This is a value that is used to seed the random number generator. By changing the random seed, we can generate different building layouts with the same parameters. This is useful for creating variations on a design or for exploring different possibilities. Basically, this ensures you are not always getting the same result, and keeps things refreshing.

These parameters will be exposed as UI elements in our custom editor window, allowing the user to easily adjust them and see the results in real-time. We'll use Unity's built-in UI elements, such as sliders, text fields, and dropdown menus, to create a user-friendly and intuitive interface. This makes it super easy for anyone to come and use the tools you have created.

Building the Custom Editor Window

Now comes the fun part: writing the code for our custom editor window. We'll create a new C# script that inherits from the EditorWindow class. This script will define the layout and functionality of our window. Here's a step-by-step guide:

Create a New C# Script: In your Unity project, create a new C# script named BuildingGeneratorEditor. Place it in an Editor folder to ensure it's only included in the editor build.

Inherit from EditorWindow: In the BuildingGeneratorEditor script, inherit from the EditorWindow class:

using UnityEngine;
using UnityEditor;

public class BuildingGeneratorEditor : EditorWindow
{
    // ...
}

Add a Menu Item: To make our window accessible from the Unity editor, add a menu item using the MenuItem attribute:
```
[MenuItem("Window/Building Generator")]
public static void ShowWindow()
{
    GetWindow<BuildingGeneratorEditor>("Building Generator");
}
```
This will add a new menu item under the Window menu called Building Generator. Clicking this menu item will open our custom editor window.
Implement the OnGUI Method: The OnGUI method is where we'll define the layout and functionality of our window. This method is called every frame that the window is open.
```
private void OnGUI()
{
    // ...
}
```

Add UI Elements: Within the OnGUI method, we'll add UI elements for each of our parameters. We'll use Unity's built-in UI elements, such as GUILayout.IntField, GUILayout.FloatField, and EditorGUILayout.EnumPopup, to create a user-friendly interface.

private void OnGUI()
{
    GUILayout.Label("Building Parameters", EditorStyles.boldLabel);

    footprintWidth = GUILayout.IntField("Footprint Width", footprintWidth);
    footprintHeight = GUILayout.IntField("Footprint Height", footprintHeight);
    floors = GUILayout.IntField("Floors", floors);
    roomsPerFloor = GUILayout.IntField("Rooms/Floor", roomsPerFloor);
    corridorWidth = GUILayout.FloatField("Corridor Width", corridorWidth);
    stairCorePosition = EditorGUILayout.Vector2Field("Stair Core Position", stairCorePosition);
    stylePreset = (StylePreset)EditorGUILayout.EnumPopup("Style Preset", stylePreset);
    randomSeed = GUILayout.IntField("Random Seed", randomSeed);

    if (GUILayout.Button("Generate Building"))
    {
        GenerateBuilding();
    }
}

This code adds labels and input fields for each of our parameters. The GUILayout class provides methods for creating simple UI elements, while the EditorGUILayout class provides methods for creating more advanced editor-specific UI elements.

Implement the GenerateBuilding Method: The GenerateBuilding method is where we'll implement the logic for generating the building based on the parameters specified by the user. This method will use the values from the UI elements to create the building's layout, room arrangements, and overall style.

private void GenerateBuilding()
{
    // Implement building generation logic here
    Debug.Log("Generating building with parameters:");
    Debug.Log("Footprint: " + footprintWidth + "x" + footprintHeight);
    Debug.Log("Floors: " + floors);
    Debug.Log("Rooms/Floor: " + roomsPerFloor);
    Debug.Log("Corridor Width: " + corridorWidth);
    Debug.Log("Stair Core Position: " + stairCorePosition);
    Debug.Log("Style Preset: " + stylePreset);
    Debug.Log("Random Seed: " + randomSeed);
}

For now, this method simply logs the parameters to the console. In the next section, we'll implement the actual building generation logic.

Implementing the Building Generation Logic

Now, let's get to the heart of our project: the building generation logic. This is where we'll take the parameters from our editor window and use them to create the actual building layout. This involves several steps:

Creating a Building Class: Define a Building class that represents the overall structure of the building. This class will contain information about the building's footprint, floors, rooms, and other relevant data.
Generating the Floor Plan: Create a method that generates the floor plan for each floor. This method will use the roomsPerFloor parameter to determine the number of rooms on each floor and the room-type mix parameter to determine the types of rooms to create.
Placing the Rooms: Implement a method that places the rooms on the floor plan. This method will need to consider the corridor width parameter to ensure that the rooms are properly connected by corridors.
Adding the Stair Core: Add the stair core to the building. The position of the stair core is determined by the stair-core position parameter.
Applying the Style Preset: Apply the selected style preset to the building. This involves setting the wall textures, floor materials, and lighting schemes according to the preset.
Instantiating the Building: Finally, instantiate the building in the Unity scene. This involves creating the necessary game objects and components to represent the building's structure.

This is a complex process, and there are many different ways to approach it. You can use techniques such as cellular automata, L-systems, or constraint satisfaction to generate the building layout. The choice of technique will depend on the desired level of complexity and control.

Saving and Loading Presets

To make our custom editor window even more useful, we'll add the ability to save and load presets. This will allow users to quickly switch between different building configurations without having to manually adjust all the parameters each time. Here's how we can implement this:

Create a Preset Class: Define a Preset class that stores the values of all the parameters in our editor window.
Implement Save Functionality: Add a button to our editor window that allows the user to save the current parameter values to a file. When the user clicks this button, we'll create a new Preset object, copy the current parameter values into it, and then serialize the Preset object to a file using Unity's JsonUtility class.
Implement Load Functionality: Add another button to our editor window that allows the user to load a preset from a file. When the user clicks this button, we'll open a file dialog and allow the user to select a preset file. We'll then deserialize the Preset object from the file using JsonUtility and copy the parameter values from the Preset object into our editor window.

With the feature of saving and loading presets, it enhances the user experience. It provides more control and reusability. This further increases the efficiency and effectiveness of the system.

Conclusion

So, there you have it! We've walked through the process of building a parameterised custom editor window for generating buildings in Unity. This tool allows you to define various parameters such as footprint, floors, room types, corridor width, stair-core position, style preset, and random seed. By implementing building generation logic and adding save/load preset functionality, you can save time and effort while unleashing your creativity to create unique and realistic building layouts within the Unity Editor. Now you can let your imagination run wild and build some awesome worlds! Happy coding, and see you in the next one!