Hello and welcome to my tutorial on how to use the Unity UI system. We’ll explore the new features and options by building a simple calculator that will respond to different display dimensions and work on multiple platforms.
This tutorial assumes a reasonable familiarity with Unity and C#. The system I’ll illustrate will work for any platform, but we’ll start with the desktop platform.
If you wish, you can download the finished project from github at https://github.com/cwgtech/UICalc.
I’ve also created three videos on youtube showing this tutorial in action:
Part 1: https://youtu.be/vQsI7wHgobw
Part 2: https://www.youtube.com/watch?v=n6gFLLSvS3U
Part 3: https://www.youtube.com/watch?v=n6gFLLSvS3U
Let’s get started by creating a new project in Unity. Unity should default to PC, Mac & Linux platform, but check by opening the Build Settings dialog. If it’s not set, then click on it and then ‘switch platform’.
Our goal here is to recreate a calculator that looks similar to the standard MacOS calculator, but it will be resizable and will adjust the width of the buttons to fill the screen or window. We’re going to achieve this by using nested layout groups to keep all the objects relative to each other, while adjusting their size automatically.
As with my other tutorials, create a few folders in the Project view to keep things organized. For this tutorial, we’ll need a Prefab folder, a Scenes folder, and a Scripts folder.
Set the Main Camera to render a black background, that will provide a backdrop for our UI. Select the Main Camera, set the Background to black (#000000FF), and then set Clear Flags to ‘Solid Color’.
Now in the Hierarchy view create a blank UI Canvas. Click ‘Create’, ‘UI’, ‘Canvas’. Highlight the Canvas object and in the Canvas script, click the ‘Pixel Perfect’ checkbox. Now select the Canvas Scaler script and change the UI Scale Mode to ‘Scale with Screen Size’. Slide the Match slider fully to the right, or type 1 in the text box. Enter ‘1000’ into the Y value for Reference Resolution.
With these changes, the UI system will constantly match the height of the screen, but as far as the UI elements are concerned, the screen is always 1000 pixels tall, irrespective of the actual screen height.
We’ll now create the UI objects that the user will see and interact with. First, create an empty gameobject under our canvas and rename it to ‘MainHolder’. Adjust the Rect Transform so it stretches horizontally and vertically to match its parent, while holding the Alt key (option on Mac).
Add the ‘Vertical Layout Group’ script to this object by clicking on ‘Add Component’, then ‘Layout’, then ‘Vertical Layout Group’. This will layout all this objects children vertically, but first we need to adjust the checkboxes. For both rows, make sure ‘width’ is checked, and ‘height’ is clear. We want this control to adjust the width of each child, but each child to control its own height.
We’re going to have two regions for our calculator. A row that will hold the digit display, and another row that will hold all the user control buttons. These rows will manage their own height, but have their width match that of the display.
Add an Image to the ‘MainHolder’ by right clicking on ‘MainHolder’, click ‘UI’, and then ‘Image’. Set this image’s height to 100 and its color to dark gray (#353535FF). Rename the Image object to ‘DigitStrip’.
Create a Text object as a child of DigitStrip by right clicking on the DigitStrip object, then click UI and then Text. Rename this object to ‘Digits’. Create another Text object as a child of DigitStrip and rename it as ‘Operator’.
Select ‘Digits’ and adjust it’s anchors to stretch horizontal and vertical, while holding the Alt key (option on Mac). Manually set the left margin to 10, and the right margin to 40. Set the default text to ‘1010101010’, the font size to ‘100’, and the color to white. Finally, set the paragraph alignment to right and vertical centered, and enable the ‘best fit’ checkbox.
This label will always fill the DigitStrip row and adjust it’s font size to allow for changes in the screen dimensions. We use the margins to inset it from the edges, and also allow space for our operator text object.
Highlight the ‘Operator’ object and adjust it’s anchors to stretch vertically and right aligned. This time hold down shift & alt (option on mac) when you click the anchor box. Manually set the width to ‘35’.
As with the Digits text, set the font size to ‘100’, color to white and check the best fit checkbox. Set the default text to ‘X’ and the vertical and horizontal alignments to center. This Text object will display the last operator the user entered, and is always to the right of the digit display.
If you now adjust the display width, you can see the Text objects change their size accordingly, and get smaller if needed, but they will always stay next to each other and at the top of the screen.
Add an empty child to the MainHolder (make sure you have MainHolder highlighted) and rename it to ‘ButtonGroup’. Set the height of the ButtonGroup to 625, which will make our buttons reasonably square on the default game view.
With ButtonGroup highlighted, add a Vertical Layout Group script just as we did before. Set the spacing to 5 (the space between rows in the group) and make sure the checkboxes are set to Width for ‘Child Controls Size’ and both Width & Height for ‘Child Force Expand’.
With ButtonGroup still highlighted, create an empty gameobject, and rename it to ‘Row (0)’. Set the height of the Row to 125 and add a Horizontal Layout Group script. Click ‘Add Component’, ‘Layout’ and then ‘Horizontal Layout Group script’. Enter 5 for the spacing value, which will set the amount of space between elements in this row, and make sure that all the checkboxes for ‘Child Controls Size’ and ‘Child Force Expand’ are set. Finally, adjust the Child Alignment to Middle Center.
Now we’re ready to start creating a button. Highlight the ‘Row (0)’ object and right click on it. Select UI and then left click on Button. This will create a default button under our Row. Adjust the color of the button background image to a light gray (#C8C8C8FF). Expand the button object in the Hierarchy view, and select the Text object. Change the Text to ‘c’, and the font size to 100. Check the Best Fit checkbox, and make sure the Min Size is 1 and the Max Size is 100.
The button will be 125 UI pixels tall and full screen width at this point. However, before we add more buttons, we will create a script for our button object, but first save the scene. Click ‘File’, ‘Save Scenes’. Navigate to the Scenes folder we created earlier, and name the scene as ‘UICalc’.
With the scene saved, right click on ‘Scripts’ and create a new C# script. Call it ‘CalcButton’. Double click it in the Project view to open it in Visual Studio. Every button will need a reference to its text label, so in our script, above the start method, add the following:
public Text label;
Right click on Text, and then ‘Quick Fix and select ‘using UnityEngine.UI’ to add this using statement to the top of the file.
Create a new method that we’ll hook up to our button function, add the following:
public void onTapped()
{
Debug.Log(“tapped: “ + label.text);
}
For now, thats all we need, so save the file and return to Unity.
After Unity updates and compiles the code, drag the ‘CalcButton’ script onto our Button object, and then drag the Text object from the Button onto the Label reference of the ‘CalcButton’ script. Click the ‘+’ button on the On Click list of the Button script, and drag the Button object into the On Click object entry. From the drop down, select ‘CalcButton’, ‘onTapped’. This will forward the event of the user clicking or tapping on our button object to the script we just created and directly to the onTapped method.
Once again, save the scene with these modifications. At this point you can run the scene, and when you click on the button, you should see the debug output in the console window. Stop the execution and continue adding more buttons.
Create a prefab object for our button by dragging the button object into the Prefab folder we created earlier. You can now drag the prefab Button back into the Row (0) object 3 times, so we have four buttons in our row. Make sure the buttons are in the order you created them, so using the Unity default naming, you should see ‘Button’, followed by ‘Button (1)’, ‘Button (2)’, ‘Button (3)’. In the Game and Scene views you’ll see the buttons appear in our row, and adjust their width as more buttons are added.
With the row ready, we can duplicate it to create all the rows in our calculator. Right click on the ‘Row (0)’ object and then click on ‘Duplicate’. Do this until there are 5 rows. You’ll see the rows adjust their vertical position as you add more rows, until we’ve got all 5 created.
At this point you can adjust the size of the Game view in Unity, and see our buttons adjust their width to fully fill the updated size, even if the scene is not running in Unity.
As I said at the start of this tutorial, we’re going to make our calculator look similar to the MacOS calculator utility, so with that in mind, let’s set the color and content for each button. We could do this with a script at runtime, but as it will never change, the editor is as good a place as any to do this.
Start with the second button, expand it to select the text object and add the ‘±’ symbol as the default text. To get the ‘±’ symbol you’ll need to enter a unicode value, which Unity doesn’t seem to support on Windows or Mac directly. Switch to Visual Studio and put the cursor at the end of the comment above our Start method.
If you’re using Windows hold down ALT and type ‘+0177’ (your computer may chime when you type the + key, just ignore it).
On the Mac, unless you have enabled unicode typing, you’ll use the character viewer so tap CTRL-CMD-Space to bring up the viewer, then type u+00B1 in the search box. Double click on the character that appears and it will be inserted into your Visual Studio text.
With the unicode character now in Visual Studio, highlight it, copy and cut it with CTRL-X (CMD-X on Mac) and then switch back to Unity and paste it with CTRL-V (CMD-V on Mac) into the text box for the 2nd button. Use the same procedure for other Unicode characters as we need them.
Set the text for the 3rd button to ‘%’.
For the fourth button, set the background color to orange (#FF6526FF) and the text to the ‘÷’ sign, (Win, ALT+0247, Mac U+00F7). Add the color to your color presets as you’ll use it for other buttons. Set the color of the text of this button to White.
Expand the Row (1) object and set each button’s text to 7,8,9 and ‘x’ respectively. For the first three buttons, set their background color to white, and the fourth button to orange.
Expand the Row (2) object and set each button’s text to 4,5,6 and ‘-’. Use the same color pattern as the previous row.
Expand the Row (3) object and set each button’s text to 1,2,3 and ‘+’. Again, use the same color pattern as the previous row.
Expand the final row, Row (4), and set each button’s text to 0,0,’.’ and ‘=’. Use the same color pattern as before. Disable the 2nd button of this row, and you’ll see the other 3 buttons expand to fill the space. We’ll add code to double the width of the first button later.
Now you can see our calculator take shape, though it has no function yet. Save the scene and run it. When you click on a button you’ll see it’s caption output to the debug console.
Create a new C# script in our scripts folder and call it Manager. When Unity is ready, drag it onto our ‘Canvas’ object. We’ll use this script to handle all the global functions for our calculator including managing the button size and the calculator logic.
Double click on the script to switch to Visual Studio and add the following lines to the top of the class:
public VerticalLayoutGroup buttonGroup; public HorizontalLayoutGroup bottomRow; public RectTransform canvasRect; CalcButton[] bottomButtons;
You’ll need to right click on VerticalLayoutGroup and select ‘using UnityEngine.UI’ to pull in the references for these classes.
Create an Awake method with the following:
private void Awake()
{
bottomButtons = bottomRow.GetComponentsInChildren<CalcButton>();
}
With this code, we’ll fetch references to all our CalcButton objects that are children of the last row into bottomButtons This will allow our code to manipulate the buttons.
Save the file and return to Unity, so we can hook up the public references to the correct objects in the hierarchy.
Expand the Canvas object, then MainHolder, and the ButtonGroup. With Canvas selected, drag the ButtonGroup object into the ButtonGroup row in the inspector, drag Row (4) into the Bottom Row entry, and finally the Canvas into the Canvas Rect entry.
Save the scene, and then double click on the CalcButton script. We’re going to add a RectTransform getter to this script, which will allow us to fetch a button’s RectTransform when we need it. Add the following after the Public Text Label line.
public RectTransform rectTransform
{
get
{
if (_rectTransform == null)
_rectTransform = GetComponent<RectTransform>();
return _rectTransform;
}
}
RectTransform _rectTransform;
This getter will return the cached copy of this object’s RectTransform, if its set, otherwise it will fetch it, cache it and then return it.
While we’re here, add one more getter method that will allow us to access the Manager script from CalcButton.
public Manager calcManager
{
get
{
if (_calcManager == null)
_calcManager = GetComponentInParent<Manager>();
return _calcManager;
}
}
static Manager _calcManager;
This time we use a static var to cache the reference as its the same for every button object. We get our reference to it by searching back up through the hierarchy.
Save this script and switch to the Manager script.
Before we write the hook code, lets setup a few other items we’ll use in a moment. Add a variable above the Awake method:
bool canvasChanged;
In the Start method add the lines:
bottomRow.childControlWidth = false; canvasChanged = true;
This allows the children of Row (4) to control their own width. We could also uncheck the checkbox for Row (4), but then our rows will no longer adjust themselves when we change the Game view in the editor (the rows will only resize to match the width of the widest row).
We’re going to use a method hook called OnRectTransformDimensionsChange that is triggered when a RectTransform of an object that has a script with this method defined is changed. This is why our Manager script is attached to the Canvas object.
Anytime the Canvas or any of its children change, this method will be called on all attached scripts. This method is actually part of UIBehavior which is a subclass of MonoBehavior.
Add the following method after the default Update method:
private void OnRectTransformDimensionsChange()
{
canvasChanged = true;
}
We set a flag when we detect a change in the RectTransform and don’t actually adjust the buttons until the update method. While this can add a 1 frame lag, it’s not noticeable, but means we only adjust the buttons once per frame and not multiple times. This hook is called when the canvas changes, and any of its children change, so it would be triggered a few times when a change is made.
Now add the method that will adjust the width of the buttons on the bottom row:
void adjustButtons()
{
if (bottomButtons == null || bottomButtons.Length == 0)
return;
float buttonSize = canvasRect.sizeDelta.x / 4;
float bWidth = buttonSize - bottomRow.spacing;
for (int i = 1; i < bottomButtons.Length; i++)
{
bottomButtons[i].rectTransform.
SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, bWidth);
}
bottomButtons[0].rectTransform.
SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, bWidth * 2 + bottomRow.spacing);
}
This method gets the current width of our canvas divided by 4, to calculate the size of one button. We adjust to allow for the spacing of the objects and then set all but the 1st button on the last row to this width, which will be the same as the standard button width. For the 1st button on the last row, we set it’s width to be twice the width of a normal button, plus the horizontal spacing.
Finally adjust the Update method to call adjustButtons if the canvasChanged flag is set. Add the following lines to Update:
void Update () {
if (canvasChanged)
{
canvasChanged = false;
adjustButtons();
}
}
Now when a change is triggered, we’ll call the adjustButtons method which in turn will set the size of the buttons on the bottom row.
Save the changes and switch back to Unity, let it update and then click Run. You’ll see the 0 button adjust to be double width, and if you change the width of the game view, you’ll see all the buttons change and the 0 button match twice the width of a normal button.
Exit Play mode and save the scene.
We’re going to add the calculator logic, but just before that, we’ll need to add some references to UI objects that we’ll hook up in the Editor and some private vars to manage the calculator logic. Switch back to Visual Studio and add the following lines to the Manager class after the public vars that we’ve already got:
public Text digitLabel; public Text operatorLabel; bool errorDisplayed; bool displayValid; bool specialAction; double currentVal; double storedVal; double result; char storedOperator;
Add a method after the adjustButtons method that will be called when we tap the ‘c’ button, to clear the calculator to a known state:
void clearCalc()
{
digitLabel.text = "0";
operatorLabel.text = "";
specialAction = displayValid = errorDisplayed =false;
currentVal = result = storedVal = 0;
storedOperator = ' ';
}
A method to update the display label:
void updateDigitLabel()
{
if (!errorDisplayed)
digitLabel.text = currentVal.ToString();
displayValid = false;
}
A method to evaluate the calculation based on the operator passed. As you’ll need to enter the unicode character ‘÷’ when typing this function, either use the method shown in part 1 of this tutorial, or switch back to Unity, highlight the button in question and copy the character from the text field.
void calcResult(char activeOp)
{
switch (activeOp)
{
case '=':
result = currentVal;
break;
case '+':
result = storedVal + currentVal;
break;
case '-':
result = storedVal - currentVal;
break;
case 'x':
result = storedVal * currentVal;
break;
case '÷':
if (currentVal != 0)
{
result = storedVal / currentVal;
}
else
{
errorDisplayed = true;
digitLabel.text = "ERROR";
}
break;
default:
Debug.Log("unknown: " + activeOp);
break;
}
currentVal = result;
updateDigitLabel();
}
Finally add the method that will process the button taps. Once again, this method requires a unicode character, specifically ‘±’ character, so use the same method as last time.
public void buttonTapped(char caption)
{
if (errorDisplayed)
{
clearCalc();
}
if ((caption >= '0' && caption <= '9') || caption == '.')
{
if (digitLabel.text.Length < 15 || !displayValid)
{
if (!displayValid)
digitLabel.text = (caption == '.' ? "0" : "");
else if (digitLabel.text == "0" && caption != '.')
digitLabel.text = "";
digitLabel.text += caption;
displayValid = true;
}
}
else if (caption == 'c')
{
clearCalc();
}
else if (caption == '±')
{
currentVal= -double.Parse(digitLabel.text);
updateDigitLabel();
specialAction = true;
}
else if (caption == '%')
{
currentVal= double.Parse(digitLabel.text) / 100d;
updateDigitLabel();
specialAction = true;
}
else if (displayValid || storedOperator == '=' || specialAction)
{
currentVal = double.Parse(digitLabel.text);
displayValid = false;
if (storedOperator != ' ')
{
calcResult(storedOperator);
storedOperator = ' ';
}
operatorLabel.text = caption.ToString();
storedOperator = caption;
storedVal = currentVal;
updateDigitLabel();
specialAction = false;
}
}
We need to add a call into the Start method that will initialize our calculator logic to a clear state when we start. Add this line to Start:
buttonTapped(‘c’);
This will simulate tapping the ‘c’ key when we start. Note that the logic uses a simple char type to check for what to do with each key. If you didn’t use a lowercase ‘c’ for the first button, then you’ll need to change what the logic expects. Save the file.
Before we can call this logic working, we need to make another change to the CalcButton script. Switch to that file and modify the onTapped method with:
calcManager.buttonTapped(label.text[0]);
This will pass the first char from the button text string to the calculator logic. There’s no error checking here, as every button has had its text string set in the editor.
Save the file and switch back to Unity. Let it update and when it’s done, highlight the Canvas object in the Hierarchy. Expand DigitStrip and drag the Digits object into the Digit Label holder, and Operator into the Operator Label holder.
Save the scene and click Play.
As you click on the buttons, you’ll see the calculator behave as expected. You can enter a number with or without a fractional part, and add, subtract, multiply, or divide it with another number. More importantly, you can do so while modifying the game view and the buttons and displays will shrink or expand to fill the view horizontally.
You can also build a stand alone app from the scene and see what happens when you modify the window size with the mouse. Click ‘File’ and then ‘Build Settings’. Click ‘Player Settings’ and then expand the ‘Resolution & Presentation’ tab. Enable ‘Resizable Window’. Click ‘Build and Run’ and enter a name for the executable, I used UICalc. Unity will build a run your application.
When the launcher appears, check windowed mode, and set the resolution to be less than full screen and click “Play!” to start our calculator. You can see as you adjust the window size, the buttons and the display will scale with the size, but always keep their relative position, and the ‘0’ button will continue to be twice the width of the other buttons.
Quit the executable, and return to Unity. If you open the Build Settings dialog again, you can now make the app even more ‘app’ like and less game like. Uncheck ‘Default is Full Screen’. Set the default width to 400 and the default height to 600. Change the ‘Display Resolution Dialog’ to ‘Hidden by Default’.
Now if you ‘Build and Run’, you’ll no longer get the resolution dialog, but the app will appear right away.
Connect your android device, or launch the emulator. While you can launch the emulator from the command line, the easiest and most convenient method is to launch Android Studio and then AVD manager. I’m using the emulator here so I can record the app running.
Set the package name to something other than default, I used ‘com.cwgtech.uicalc’. Click ‘Player Settings’, expand the ‘Other Settings’ tab and type in the new package name. We don’t need to make any other changes at this time, so we’ll click ‘Build And Run’ to build the APK and send it to our Android device. Once again, I used the name ‘uicalc’.
With the app running, you can see the calculator looks as expected, and works just like it did on the desktop. If you rotate the device, you’ll see the buttons adjust for the landscape view and fill the new wider look.
You can continue to rotate the device and see that it works in all four orientations.
Assuming you have the ability to build for iOS, open Build Settings and switch to the iOS platform. In my case, I want to build for the simulator, so click ‘Player Settings’, expand the ‘Other Settings’ tab and select ‘Simulator SDK’ in Target SDK.
Click ‘Build and Run’, enter the name of a folder for the project, I like to use iosBuild, and the project will build and launch in XCode.
Now we can run the app on the simulator, and pick an iPhone model. The app contents will adjust to fill the display horizontally, and also continue to do so if we rotate the device.
Likewise, if we run it on an iPad device, the app will adjust for the different display resolution and aspect ratio, and still handle the rotation correctly.
That completes my Unity UI system tutorial. I’m hoping this inspires you to use Unity to create multi-platform non-game apps. Having a system that can provide your users with a UI that adapts to different displays and orientations is a great thing for them. Having a system that lets you use the same code on multiple platforms is a great thing for you!
As always, you can follow me on Twitter @cwgtech, or check out my blog at www.cwgtech.com. Please feel free to leave any comments or suggestions below, see you next time.