Build real-time 3D industrial apps faster: Essential tips from the Unity Industry Fundamentals template

From prototypes to training applications, digital twins, human-machine interfaces, and product configurators, there’s almost no limit to the variety of applications you can develop and launch with Unity Industry.

Are you curious about how your organization can use Unity, a new subscriber, or a more experienced Unity Industry developer looking to advance your skills? Whether you’re opening the Editor for the first time or a long-time developer who’s shipped multiple projects, it’s always useful to learn about how to harness Unity’s powerful features most efficiently, making your day-to-day work experience as productive and enjoyable as possible.

Boost productivity with CAD-to-3D conversion, responsive UI, code architecture, and more

This guide provides an overview of the Unity Industry Fundamentals template, a new in-Editor learning template for Unity Industry developers.

Key takeaways from Industry Fundamentals

Through a series of tutorials, the Unity Industry Fundamentals template shows you the steps for implementing important features in Unity Industry projects, including:

• How to use the Asset Transformer Toolkit to convert and optimize CAD to 3D assets that are ready to use in a real-time industrial project
• How to build an HMI and connect the UI with real-time data
• How to implement a navigation system that accommodates both automated and manual navigation
• How to set up virtual cameras so users always have the view they need in simulations of complex and large environments
• How to architect C# scripts that handle robot behavior, state management, and data flow using ScriptableObjects to keep the data layer decoupled

The aim with Industry Fundamentals is to help make your Unity development experience more efficient, focused, and productive. The tips you’ll pick up apply across many types of real-time 3D industrial applications, including human-machine interfaces (HMIs), training simulations, digital twins, and product configurators.

Get the Industry Fundamentals template

Before we start, here are the steps to find and download the template if you haven’t done so already.

If you are a Unity Industry subscriber:

1. Open the Unity Hub and upgrade to Unity 6.4

2. Create a new project and then search for Industry Fundamentals, or go to the Learning category and select the template there.

If you don’t have a Unity Industry subscription:

1. Go to our free trial page and follow the instructions to get a free trial.

2. Once your trial is up and running, follow the same steps as for Industry subscribers.

A template you can explore and modify

The template consists of four tutorials that guide you through the workflows and steps to create a 3D interactive industrial application. Once the project is open in the Unity Editor, you’ll find the finished scene, called Warehouse, in the Scenes folder. This scene is a fully built warehouse environment with multiple robots distributed across the floor, ready to retrieve, stock, and move inventory.

The demo scene is designed for rapid prototyping; simply drag and drop your own 3D model into the scene, attach a single component, and everything is automatically wired up. Your asset will appear in the UI and instantly behave as an autonomous robot, moving through the environment and responding to UI inputs and outputs.

Open the Game view, enter Play mode, and begin to interact in the simulated warehouse via a UI that lets you control and monitor each of the robots, displaying live data like a robot’s battery power and health level. The UI provides a miniature map that shows you where the robots currently are. You can also manually override some of the robot settings by switching from auto to manual mode, and control the movement of each robot with the WASD keys. Adjust the speed of each robot and use the slider to lengthen or shorten its arm.

Let’s look at the main features of this warehouse simulation.

Watch: Getting started

The Asset Transformer Toolkit: From CAD to optimized 3D assets

CAD software prioritizes mathematical precision and geometry-based detail in its models, whereas real-time applications need to balance visual quality with practical performance considerations like a manageable polygon count, efficient texture sampling, and hierarchies it can cull and batch.

The Unity Asset Transformer Toolkit, included in the Unity Industry license, is the bridge between your organization’s CAD data and your Unity projects. It seamlessly integrates your existing data with Unity via automated data preparation workflows, saving you time and effort. You can import any 3D or CAD file type and eliminate the need for multiple imports or model recreation, with full control over mesh size and quality, which optimizes your data for performance on your target devices.

In the Industry Fundamentals example, you’ll see how to import a new robot asset into Unity. The robot model, which is based on the original CAD file, is a heavy asset with a rough look not suited for a polished presentation. The Asset Transformer Toolkit is used to convert and optimize the models for use in an interactive 3D application suited for platforms like desktop and the web.

To see how to install and open the Asset Transformer Toolkit in the Editor watch the video at the end of this section.

Let’s start by looking at the toolbar.

Explore the Asset Transformer Toolkit toolbar

Here’s a brief explanation of the actions available in the toolbar:

• Import Model: Click this to start the import process to bring your CAD data into Unity.
• Mesh and Optimize: Use these to decimate geometry and remove any unnecessary details, for example, holes or internal faces.
• Remesh: This feature enables you to completely rebuild the geometry for high performance use cases.
• Hierarchy: Use these to clean up any messy object structures brought over from the CAD assemblies.
• Transform: Quickly fix your pivot points and alignment issues in the model.
• UV and Colliders: Use these settings to generate the data Unity needs for texturing and physics-based interactions.

Keep model settings and modifications when you import

This guide doesn’t cover the import process in detail; the in-Editor tutorial and the video at the end of this section will walk you through all the important steps.

What’s key to highlight here is that when you choose the file you want to import, a ScriptableObject is created, with the same name as your model, in the Assets folder in the Project window.

This is not the actual model; the advantage here is that the ScriptableObject contains a collection of settings that you can use to import the model, allowing you to keep its settings and modifications. If changes are made to the CAD model and you need to re-import it, you don’t have to set up everything from scratch again. All of those settings will be saved in the ScriptableObject.

When you select the ScriptableObject and its Inspector window opens, you’ll see the Import Mode field at the top, which can be set to Prefab or Scene:

• Prefab: For single objects
• Scene: For very large and detailed assets, like a high-rise building with thousands or even millions of objects

The Inspector also provides three tabs: Model, Rule Engine, and LODs:

• Model: From here, you can set the model import parameters. This is the step where the raw source model is converted into an optimized 3D asset.
• Rule Engine: Define a Rule Set that allows you to automate the data preparation of your model straight from the ingestion step. Rule Sets are especially useful when you need to reimport your source model as it evolves. See the next section for an introduction to the Rule Engine and Rule Sets.
• LODs: Add LOD rules to generate LODs; these can be generated directly during the model import process, as a final step.

Once your settings are ready, click Import and the model prefab will be added to the Assets > 3DModels folder in the Project view. You can drag and drop the model into the Scene view, which also adds it to the Hierarchy.

Watch: Install the Unity Asset Transformer Toolkit

Optimize the 3D assets

The Asset Transformer Toolkit provides tools to clean up imported models, preparing them for a real-time environment, while maintaining visual fidelity and any required metadata. This can be done automatically during the import process using the aforementioned Rule Sets, or manually after import as individual actions using the tools on the Asset Transformer toolbar.

Clean up the Hierarchy

In the template, if you go through the steps of importing a new robot asset, you’ll see that its structure in the Hierarchy is overcomplicated. Click down to one of the basic elements, such as the GameObject called body_body_main_01-1 and you’ll see in its Inspector that all of the metadata associated with that part is added in a component. However, its child object contains the mesh filter which shows the actual geometry as well as the material information currently assigned to it.

It’s more efficient to have all of that detail in one object together with the metadata and not separated.

To fix this, use the Merge tool. By default, the Merge tool is set to Merge Everything. You don't want to apply this, since it will merge everything into a single prefab. You want to keep the final level of all of the objects. If you select the Final level option in the drop-down, it will tell the Merge tool to iterate down the list in the Hierarchy and find the last object in every tree, and then merge back to the one just above it.

See additional steps in this video.

Decimation

You can remove unnecessary geometry in a model to make it more lightweight. The Statistics option in the Asset Transformer Toolkit displays stats for a selected model, or part of model. The CAD model that you will import in this template tutorial has 510 GameObjects and more than 600,000 triangles pre-optimization, making it a really dense model. Watch this video to see how the holes in the new robot model are removed.

Inspect the density of the model by activating the Debug menu and changing the view to Vertex ratio. This shows in red where you have objects that are extremely dense in relation to everything else in the scene. This is a good indicator of where you can use decimation to optimize a model.

Decimation can be a tedious process if you have a lot of geometry in your model as in this case. So you also have the option to decimate at scale.

By setting the Criterion option in the decimation tool to Quality and selecting the top level of the CAD model in the Hierarchy, you can select a target quality level and then run the tool to apply the decimation to everything.

When applying this action to the robot asset with the quality set to low, there was a 65% reduction in triangles, with their number now at just under 200,000, making it optimized to run on mobile.

Adjust the normals

One problem that often arises with heavy optimization like this is that it can break the smoothness of a model. How it looks and presents itself under light may change after decimation where suddenly you see artifacts or maybe harder corners than you had before. That can be fixed by adjusting the normals on your model. The Asset Transformer Toolkit provides a number of tools that allow you to adjust or reset the normals of your model.

Watch: Optimize the CAD model

Use Rule Sets to save time when reimporting assets

CAD models often go through numerous iterations during the design process, and it can become inefficient if you have to run all of the above actions every time you reimport a model after changes are made in the CAD application.

Depending on where you are in the design process and how many design iterations you have, that can become a tedious process.

That’s where rule sets provide a major advantage. Rule Sets, which you set up in the Asset Transformer Toolkit’s Rule Engine, are a sequence of instructions, called Actions, that Unity follows during import, or that you can apply manually, that automate many of the actions that you typically want to apply to a CAD model.

Create a Rule Set

A Rule Set is essentially a recipe that directs the Asset Transformer Toolkit to find the specific object or objects based on given criteria and then apply the action that you specify. As an example, when you see this material name in the CAD file, map it to this Unity material. When you find parts named with this pattern, group them together. When the polygon count exceeds this threshold, generate LOD levels. These rules let you automate what would otherwise be tedious manual work.

The Industry Fundamentals template includes several pre-built rule sets in the Rule Sets folder. They're worth studying, not just for what they do, but for how they can get you to think about prioritizing optimizations. In the template, one Rule Set handles the robot model, which needs high detail on the arm joints where users will focus their attention, but can get away with lower detail on the base where it's less visible. Another handles the warehouse environment, where the geometry is simpler but there's a lot of it, so aggressive LOD generation makes sense.

There is a Rule Set that will apply the decimation and Hierarchy clean up actions as an automated process during import. The template also provides another Rule Set that will automatically bake ambient occlusion into the vertex data to increase the visual fidelity of the model. Finally, there are Rule Sets that will show you how you can swap out materials and objects during the import process

To create a Rule Set:

1. In the project folder, right-click and select Create > Asset Transformer > Rule Set.

2. Set the name for your Rule Set.

3. Edit the Rule Set from the dedicated Tab (automatically opens next to the Inspector)

4. Add items to the sequence, for example Filters, Actions, and additional Rules. Rules are applied sequentially, from top to bottom.

If you look at the image below, on the right, a Rule Set is open. The first action is by default set to Get. This will get an object in the scene and everything that follows after that will be applied to that selected object.

The Get action will select the entire robot model, and any subsequent actions will be applied to the entire robot model, so you need a way to find the specific elements inside it that you want to apply the subsequent actions to. To do that, add a Filter Action to this rule and set the Action to Filter on Metadata to use the metadata that is imported with the CAD model.

Reimport assets efficiently

Rule sets like the ones above can be run manually by:

• Selecting the object or objects that you want to apply to
• Selecting the rule set and then clicking on the Run button

However, you can also set it up so that the Rule Sets will are applied automatically as part of the import process. To set that up, select the import settings ScriptableObject that was created in the Assets > 3DModel folder, and you'll see in its Inspector that the Import button is now named Re-import.

Select the Rule Engine button and then specifying the Rule Set that you want to run during the import process.

If you select the Re-import button after setting this up, every time that the CAD model is re-imported, the specified rule will be applied to it. You can also nest multiple rules and Rule Sets inside the import rule to make sure that they all get applied during the import process.

Watch: Rule Sets

Watch: Advanced Rule Sets

Add a new robot to the template

Once you’ve looked at how you can import, optimize, and then automate that whole process, it's time to turn this CAD data into a functional, data-driven robot within a simulation.

The template provides all the components you need to follow along in the process, including C# scripts to link your model to the UI and set it up so that you can switch between the different robot variants, and test the robot's behavior in real time.

Let’s look at one of the workflows explained in the template.

There are several robots in the warehouse scene, and you want to set up any new robot model so it has the same functionality as the others. To do that, you’ll reimport the model, an efficient and predictable process now that you have rule sets in place. Here are the steps:

1. In Project > 3DModels, you’ll find the import ScriptableObject asset that contains all of the settings set up previously. Open its Inspector, and check in the Rule Engine tab that you have the import rules set up.

2. In the Model tab, check that the Import Metadata setting is selected. This is critical for the filters and all of the Rule sets to work.

3. After reimporting the model, you will find it in Assets > 3DModels, and from there you can drag and drop it into the Scene view.

4. In the Hierarchy, you’ll notice that the existing robots in the scene are nested under a parent Robots GameObject. Expand this, select one of the child robot objects, and you'll see that it has a Robot script attached with a Robot Data ScriptableObject, which contains all of the information for each robot.

5. If you look in the Assets > Warehouse > RobotData folder, you'll see that the four robots currently in the scene each have their own individual RobotDataSO ScriptableObject. You’ll need to attach the same ScriptableObject to the new robot.

6. To do that, right-click in the Assets folder, and select Create > Industry Template > Robot Data. Name it to correspond with the robot model number.

7. Click on the new robot you’ve added to open its Inspector, then click Add Component, look for the robot script in the drop-down, called Robot.cs and add it.

8. Drag the new robot ScriptableObject into the Data field of the new script, and it will automatically add all of the other scripts and components that you need for this robot to behave like the others.

Follow along with the tutorials in the template to see each step for taking your CAD data, bringing it into a real-time application to create a digital twin, and setting up the controls to monitor the robots through the UI.

Watch: UI and interactivity

Create a monitoring dashboard with UI Toolkit

Unity has two systems for creating user interfaces (UI): Unity UI (uGUI) and UI Toolkit. Industry Fundamentals uses UI Toolkit.

UI Toolkit is designed for optimal performance and adaptability across platforms and is inspired by standard web technologies. If you have experience developing web pages or applications, the core concepts of UI Toolkit should be familiar to you. UI Toolkit provides powerful tools and workflows that leverage your existing knowledge of markup languages and style sheets.

UI Toolkit: Inspired by standard web technologies

With UI Toolkit, you can separate the structure, style, and behavior of your UI, similar to how you might with HTML, CSS, and JavaScript.

UXML is a markup language inspired by HTML and XML that defines UI structure and reusable templates. While you can build UI in C#, using UXML provides the ability to work on UI layouts within Unity’s UI Builder window, which provides a visual authoring experience.

USS are style sheets that apply visual styles and layout rules to UI. Similar to CSS, USS supports a subset of standard CSS properties. While you can define styles in C#, using USS is recommended because it ensures styles can be reused across the UI, creating a unified look and simplifying their management.

UI Toolkit supports a data binding system that allows you to link properties of UI elements to data sources. This means that when the data changes, the UI updates automatically, and vice versa.

In this section, we’ll look at the design of the dashboard and how it works with data binding.

Wiring up the dashboard in Industry Fundamentals

The dashboard has distinct sections, with overview information at the top, a list of robots on the left, and details and controls on the right. The dashboard’s USS file defines a complete design system, like color and spacing variables, and classes for repeated elements like buttons and status indicators.

Each robot has three status states, standard, warning, or critical, which need visual representation. The USS defines three classes – status-standard, status-warning, and status-critical, each with a distinct background color. A C# script adds and removes these classes based on a robot's state. Health degrades over time when the robot's battery drops below a critical threshold; the lower the battery, the faster the health loss. If the robot's health or battery falls into warning or critical ranges, the status classes update accordingly, giving operators an instant visual signal on the dashboard.

In a real-world project, this separation means designers can adjust the warning color without touching code, and programmers can add new status types without understanding CSS.

UIController script

The UIController script ties everything together. It caches references to UI elements on startup, registers event callbacks for buttons and sliders, subscribes to the Robot Manager's events, and updates the UI when state changes. The template shows both approaches to UI updates: data binding for continuous values like battery level, and explicit code for discrete events like robot selection.

Data binding

Instead of writing code that manually updates every label and progress bar, you declare bindings in UXML that connect properties of the UI elements to properties on the data source. When the data changes, the UI updates automatically.

The template binds UI elements directly to each robot’s RobotDataSO ScriptableObject. This provides its battery level, health, temperature, and speed. The UXML declares bindings like "the text of this label should be the Battery property of this data source, formatted as a percentage."

This binding is bidirectional; for example, the arm range slider doesn't just display a value, it also sets it. When the user drags the slider, the bound property updates, which moves the robot arm. The UI becomes a control surface, not just a display.

Converters are an essential part of data binding, handling the gap between data types and display formats. Battery is a float from 0 to 100 on the data source, but you want to display "75%" not "75.0". The template includes converter assets that register formatting functions. You reference these converters in your bindings, and they transform values on the way from data to display.

The minimap

The minimap demonstrates custom rendering inside UI Toolkit. The minimap background is a Render Texture from an overhead camera. The robot position dots are UI elements positioned based on world coordinates transformed into UI space. Every frame, the code reads each robot's world position, calculates where that maps to on the minimap element, and updates the dot's position – a simple but effective technique for showing spatial relationships.

Watch: UI deep dive

Set up auto and manual navigation

How do the robots know where they can move? The warehouse is full of obstacles – shelves, pallets, other robots – and each robot needs to find paths around them. This is the job of Unity’s AI Navigation system.

If you open the warehouse scene in the Editor, go to the top toolbar and click on the Toggle Visibility button, the NavMesh appears in the scene as a blue overlay. A NavMesh is a mesh that Unity generates to approximate the walkable areas and obstacles in an environment for path finding and AI-controlled navigation.

The more performant option is to bake your NavMesh into the scene instead of creating it at runtime. During the baking process, the Navigation system looks at your scene and, based on the parameters that you've set, it finds all of the areas where agents (in this case, the robots) can move.

In the template, each robot knows its route because it has a NavMesh Agent component attached. It also has some presets that you can adjust, for example, its speed, acceleration parameters, the radius of avoidance, and the height.

While a lot of the movement logic is managed by the NavMesh system, in Assets > Warehouse > Scripts there’s also a RandomAgentMovement script that handles setting target destinations. The scene has specific predefined destinations. At runtime, this script will assign one of those destinations to a robot and then it will constantly check how far that robot is from it. If the robot gets to that destination, it pauses there for a few seconds. Then the script assigns a new target destination; because of the NavMesh, the robot automatically determines and sets out on the optimal path to its destination.

A challenge can arise in an application where any number of objects can be manually controlled alongside autonomous agents like the robots. The robots need to be aware of moving objects, like a door opening and closing or a moving crate. For the robots to have awareness of these movements, it must be built into the NavMesh setup.

To manage this in Industry Fundamentals, a NavMeshObstacle component is added to the NavMesh system. This tells the NavMesh to carve out a specified area around a robot. As the robot moves, the area moves with it, preventing the robots from moving through elements like shelves, or clashing with other robots.

If you switch to manual mode to control the robots, the NavMeshObstacle component is assigned and activated, while the NavMeshAgent component is disabled.

The switch between modes happens through the robot's data ScriptableObject. The OperationMode property is either Auto or Manual, and various components check this value to decide what to do. The UI has buttons to toggle the mode, which update the data asset, causing the components to react. This data-driven approach means adding new modes or changing mode behavior doesn't require touching multiple scripts.

Watch: NavMesh walkthrough

A virtual camera system with Cinemachine

The Industry Fundamentals template uses the Cinemachine virtual camera system (which you can download as a package) in three ways:

• To create the camera that follows the active robot, and to provide the smooth blending between the different robots as you select different cards
• To keep the camera locked on its robot as it moves around the warehouse and make sure that you're not clipping through different objects
• To push the 3D view directly to the dashboard UI

The core concept is straightforward: You have one Unity Camera GameObject in your scene, managed by a Cinemachine Brain component, and multiple virtual cameras that define potential shots. The Brain component switches between virtual cameras based on their priorities. Only the highest-priority enabled virtual camera controls what you see.

The cameras in Industry Fundamentals

If you open the warehouse scene, you’ll see a few robots scattered around, providing you with elements to work with before adding your own robot. You’ll have to make sure that when you add your own robot to the scene that is also has a virtual camera assigned to it.

In the Hierarchy, find the Cinemachine Shots GameObject that provides a default shot.

When you hit Play each robot will have its own “follow” camera, added through a script at runtime. That script gets a list of how many robots are in the scene, including new ones added, and for each of those, it creates a Cinemachine Camera component as well as a Third-Person Follow component. The Third Person Follow component allows you to create a camera that sits behind the moving object, and will then follow whichever object is assigned as the tracking target.

For the dashboard UI, Cinemachine is implemented in two different ways: A 3D camera to show the currently rendered camera, and one for the minimap. The minimap uses a Render Texture with a separate camera that renders the view from the top and then outputs that view to the Render Texture. The 3D camera does not use a texture but renders the view from the actual camera from the running application, however, through a rectangle cutout in the UI.

Cinemachine allows you to build flexible camera systems where the Cinemachine brain will handle all of the logic of jumping between those different cameras, creating virtual cameras that act as position holders for the actual main camera. Finally, it provides additional components like the third-person follow camera that does a lot of the heavy lifting that typically comes with building a real-time application.

Watch: Cinemachine walkthrough

Optimize lighting with the Universal Render Pipeline

The Universal Render Pipeline (URP) is Unity's solution for scalable rendering. It's designed to produce high-quality visuals while running efficiently on everything from high-end desktops to mobile devices and web browsers. For industrial applications, this flexibility is crucial. You might need the same application to run as a kiosk display at a trade show, as a web app for remote customers, and as a tablet app for field technicians.

The template's URP configuration is in the Settings folder. The Render Pipeline Asset controls global rendering settings. Understanding what these settings do helps you make intelligent adjustments for your own projects.

Forward+ rendering

The template uses Forward+ rendering, which handles multiple lights efficiently while maintaining compatibility with a wide range of hardware. Forward+ works by clustering lights in screen space, so adding more lights to your scene doesn't negatively impact performance the way it would with traditional forward rendering.

Anti-aliasing smooths out the jagged edges that appear where geometry meets the background. The template uses MSAA at 4x for the high quality tier, 2x for medium, and none for low. MSAA is fast on modern GPUs but uses more memory, so the tiered approach lets you scale based on the target device.

Use shadow cascades

Shadows enrich visual quality but can be computationally expensive. The template uses shadow cascades, which provide high-resolution shadows near the camera and lower resolution shadows in the distance.

A mix of baked lights and light probes

Lighting in the template uses a hybrid approach. Static geometry like the warehouse floor, walls, and shelving, use baked lighting. Dynamic objects like the robots use real-time lights and light probes.

Light probes are invisible points in your scene that sample the baked lighting. When a dynamic object moves near a light probe, it picks up the ambient lighting from that location. The template has light probes placed throughout the warehouse so the robots feel integrated into the environment rather than sitting on top of it.

The LightRig system adds another layer. Each robot has a set of spotlights that activate when that robot is selected. This creates visual focus on the active robot without requiring expensive global illumination. The implementation is simply a component that enables and disables lights based on selection state.

Environment lighting comes from an HDRI image that provides the subtle ambient light that fills in shadows and gives metallic surfaces something to reflect. The template includes several HDRI options so you can see how different lighting environments affect the mood of the scene.

C# scripts

Let’s look at the scripts, and the ScriptableObjects, that are used in the template.

As described in previous sections, all of the details of a robot, such as its movements, how it breaks down, and how it reports back to the UI, are contained in a ScriptableObject. If you go to the Project view and then Assets > Warehouse > RobotData, you’ll find each robot’s ScriptableObject. Open the Inspector of one of these and you’ll find the robot’s details like its name, current operation mode, current status, the variant that is active, battery, health, running temperature, speed, and so on. The ScriptableObject doesn’t do anything on its own; in this context, it’s simply a container that holds all of the data specific to that one model.

There is also a ScriptableObject holding data for the entire fleet of robots, including average battery levels across all of the robots, how many of them are moving, and how many of them are in each status category. This is all communicated to the dashboard UI.

Scripts are used to link all of this data with the actual robots and give them functionality, for example, movement or switching between the different variants. In the template you’ll find them in the Warehouse scripts folder. There are scripts to drive the robots and to link all of the ScriptableObjects with an actual model. Select one of these and you’ll see that there are Robot, Simulator, and Variant scripts.

RobotManager

The RobotManager script brings all of the data to life at startup. This script is a singleton, so there's one instance of this in the whole scene. When the application starts, it will discover every robot in the scene, and then store them in a list. This script contains two crucial events: ActiveRobotChanged, which fires every time that a user selects a different robot, and RobotListChanged, which fires when a robot is added or removed from the list.

This script is the backbone communication of the entire project. As you go through other scripts, you'll see that many of those subscribe to these events.

The OverallDataUpdater script runs every frame and tells the OverallData ScriptableObject to loop through each robot's data, tally up the numbers, and update the fleet summary. So, while the overall data contains all of the information, this is the script that actually makes it work.

Each robot uses the NavMesh to understand where it can and can’t move. But they also need something to move towards, and as explained earlier, each robot can operate in auto or manual mode. To manage all of that, the template has a RobotEditor script, via Assets > Warehouse > Scripts > Editor. This script automatically adds everything that you need to a robot prefab when you assign a ScriptableObject to it.

The RandomAgentMovement script is active when the robots are in auto mode. This script has an array of targets. When the script starts, it picks one at random and sends the agent toward it. Every frame, it checks if the agent has arrived. It looks at the remaining distance, whether the path is still being calculated, and whether the agent has stopped moving. Once all three of those conditions are met, it waits a random amount of time (one to three seconds), then picks a new target and the robot starts the whole process again.

As you’ll see in the simulation, the robots wander around the warehouse and at each destination, they pause a moment as if they're doing something there, then turn and move to the next target.

And, as you might remember, when you switch to manual mode the Robotscript disables the NavMesh Agent component and activates the NavMesh Obstacle component with carving enabled. A robot with that component activated will move over the NavMesh and carve out an opening on the NavMesh around it. When another robot on auto mode gets close to it, it won't be able to go through it since there's an opening in the NavMesh; it will find a new path around it. When you switch back to auto, it will remove that Nav Mesh Obstacle component and re-enable the NavMeshAgent.

The RobotDataSimulator script simulates what would happen in an actual environment, like the batteries draining as the robots move around, things breaking down, etc. This script also writes updates to the ScriptableObject, which in turn informs the UI dashboard what to display.

Finally, for each model, the Variant script is where you can specify the different variants and their behavior. When you select the button that switches between the variants, this script will enable and disable the relevant ones.

Watch: C# architecture and ScriptableObjects

Performance optimizations

Industrial applications often need to work well across multiple hardware devices which means thinking carefully about how to optimize the experience. Here are some of the strategies used in the template.

• Update frequency management: Not everything needs to happen every frame. The telemetry simulator updates every frame because users expect instant feedback when driving manually. The aggregate statistics update once per second because fleet-wide averages don't change meaningfully faster than that. The template makes this configurable, so you can tune the tradeoff between responsiveness and CPU usage.
• UI query caching: UI Toolkit's Q method finds elements by name or class, which is convenient but comes with some cost. Calling Q every frame to find the same element wastes cycles. The template queries once at startup, stores references in fields, and uses those cached references thereafter.
• NavMesh query optimization: Full pathfinding, where you calculate the complete path from A to B is expensive, but validating a single point is cheaper. The manual controller uses NavMesh.SamplePosition instead of CalculatePath because it only needs to know if the next step is valid, not the entire route.
• LODs: The robot model has multiple detail levels, automatically selected based on screen size. In close up, you’ll see the full details, while a robot further away has simplified geometry that still reads correctly. The template's LOD thresholds are tuned for the warehouse environment; you'd adjust them based on your scene's typical viewing distances.
• Render texture resolution: This balances quality against GPU memory and fill rate. The security camera and minimap don't need full resolution so they render to smaller textures. This reduces the pixels the GPU needs to fill and the memory those textures consume.
• Physics layer filtering: The template puts robots on a "Bot" layer and configures the physics settings so only relevant layers collide. Robots collide with the ground and each other, but not with UI raycast targets or other systems that use colliders for non-physics purposes.
• Quality tiers: The template defines three tiers with progressively reduced settings. At runtime, you'd detect device capability or provide user settings, then call QualitySettings.SetQualityLevel to switch. The URP Render Pipeline Asset supports per-tier overrides, so you can cut shadow resolution on low-end devices without affecting high-end ones.

Finally, Unity’s profiling tools are essential for finding bottlenecks. Profile on target hardware, find the hot spots, and optimize those specifically rather than prematurely optimizing everything.

The Unity Industry ecosystem

Unity Industry includes the products and support needed to create, manage, and scale multiplatform applications. Designed for industry creators, it covers every stage from data integration to deployment.

Join top companies in manufacturing, automotive, retail, and more that use real-time 3D technology to gain a competitive edge, accelerate time to market, and optimize resources. From product visualization to simulations, Unity Industry powers immersive experiences.

Get the Industry Fundamentals template

If you are a Unity Industry subscriber:

1. Open the Unity Hub and upgrade to Unity 6.4

2. Create a new project and then search for Industry Fundamentals, or go to the Learning category and select the template there.

If you don’t have a Unity Industry subscription:

1. Go to our free trial page and follow the instructions to get a free trial.

2. Once your trial is up and running, follow the same steps as for Industry subscribers.