What is AAXLP?
AAXLP (AI-Assisted XR Layout Planning) is a factory floor layout planning application for VIROO-based VR projects. It lets users design and edit a factory layout in VR using voice commands, ChatGPT AI command parsing, and direct object manipulation. The module is fully embedded inside the Unity project (not a separate installed package after initial import).
AAXLP System Architecture — showing the relationship between voice input, AI pipeline, layout editing, and data persistence
Installation
Pre-requisite: Install all required packages before importing the AAXLP package file.
-
Install VIROO Studio 2.6.941
Follow the official VIROO documentation to install VIROO and all its dependencies. AAXLP was built and tested with VIROO Studio version 2.6.941.
-
Install OpenAI Unity Package
In Unity Package Manager → Add package from git URL:
https://github.com/srcnalt/OpenAI-Unity.git
-
Install Unity Sentis (Inference Engine)
In Unity Package Manager → Add package by name:
com.unity.sentis
Note: Unity Sentis has been rebranded to "Inference Engine" in newer Unity versions.
-
Import the AAXLP Package
In Unity: Assets → Import Package → Custom Package…
Navigate to and select the AAXLP .unitypackage file. Import all contents.
Layer Configuration
AAXLP requires layers 16–21 to be set exactly as follows. These must be configured manually in Edit → Project Settings → Tags and Layers.
16 Floor
17 Placing
18 Ceiling
19 Wall
20 Boundary
21 WallPoint
Layers 22–29 are free for your own use.
Correct Layers tab configuration
VIROO also uses a custom layer configuration. You can set VIROO's layers automatically from the Viroo Project Validation window, but AAXLP's layers 16–21 must be assigned manually.
Project Configuration
-
Enter OpenAI API credentials
Open Assets/Scenes/VR scene. Select the Manager GameObject in the Hierarchy. In the Inspector, find the ChatGPTController component and enter your OpenAI API key and Organization ID.
-
Set Active Input Handling to "Both"
Edit → Project Settings → Player → Other Settings → Configuration
Set Active Input Handling to Both.
-
Add "VIROORoot" tag
In Edit → Project Settings → Tags and Layers, add a new tag named exactly VIROORoot. Then in the VR scene, assign this tag to the Root GameObject.
-
Remove Space key from Submit input
Edit → Project Settings → Input Manager. Find the Submit input and clear the Alt Positive Button field (remove "space").
-
(Optional) Configure desktop testing
To test in the Unity Editor without a VR headset, configure the VIROO bootstrap mock. See the screenshot below for the correct settings.
VIROO Bootstrap Mock configuration for testing without a VR headset
Testing the Installation
-
Open the VR scene
Open Assets/Scenes/VR.unity in Unity.
-
Enter Play mode
Press the Play button or Ctrl + P.
Expected result: the "Welcome to AAXLP" starting menu appears after a few seconds with no error messages in the Console.
-
Test Free Mode — New Layout
Select four or more wall points in the environment to define a room boundary. Name the layout. The room should generate without errors.
-
Test Free Mode — Item Manipulation
- Spawn item: press Q to open the commands menu
- Delete item: press Left Mouse Button while looking at an item → options menu → Delete
- Move item: hold E while looking at an item
- Connect items: options menu → Manage Connections → Add a New Connection → click another item
- Miniature mode: drag the World Scale slider (top right) — connections are disabled in miniature mode (expected)
-
Test Load Layout
Stop and restart Play mode. From the menu choose Load Layout — your saved layout should appear and load successfully.
-
Test Scenario Mode
Load each available scenario and follow the voice instructions. Complete each scenario without errors.
The "Go back to starting menu" button does not work in the Editor (VIROO limitation). To return to the menu, stop Play mode (Ctrl+P) and restart it.
System Architecture — Script Responsibilities
→
→
AI Parse
ChatGPT Controller
→
Command
Item Handler / Command Wheel
→
📂 Load / Save Layout
| Script | Responsibility |
AinakJSONReader | Reads saved layout JSON files from disk |
RoomGenerator | Reconstructs room geometry from layout data |
WallPlacer | Places boundary walls for new layouts |
FileControl | Handles save/load file operations |
🔧 Layout Editing
| Script | Responsibility |
ItemHandler | Spawn, move, rotate, delete factory items |
CommandWheel | Radial menu for item commands |
BoundaryChecker | Prevents placement outside room bounds |
PathVisualizer | Draws connection lines between items |
🎤 Voice AI Pipeline
| Script | Responsibility |
RunWhisper | Speech-to-text using Whisper Tiny model |
Audio Recorder | Records microphone input |
ChatGPTController | Sends text to OpenAI, parses AI response into commands |
Scripts located in Assets/STT Whisper Tiny/Scripts/
📍 Script Locations
Assets/Scripts/ — all main AAXLP scripts
Assets/STT Whisper Tiny/Scripts/ — RunWhisper, Audio Recorder
- Manager GameObject in VR scene — hub for ChatGPTController, ItemHandler, WallPlacer, RoomGenerator
Unity Events Reference (20+ endpoints)
All AAXLP events are accessible in the Inspector via the (+) button on each script. Use them to trigger custom functions without coding.
| Script | Event Name | When it fires |
| AinakJSONReader | onLayoutLoaded | After a saved layout is loaded successfully |
| AinakJSONReader | onLayoutSaved | After the current layout is saved to disk |
| AinakJSONReader | onItemsProcessed | After all items in a loaded layout are instantiated |
| ItemHandler | onItemSpawn | When a new factory item is spawned |
| ItemHandler | onItemDelete | When an item is deleted |
| ItemHandler | onItemMove | While an item is being moved |
| ItemHandler | onItemRotate | While an item is being rotated |
| CommandWheel | onStartedMoving | When move mode begins on an item |
| CommandWheel | onFinishedMoving | When move mode ends |
| CommandWheel | onConnected | When two items are connected |
| ChatGPTController | onResponseFinishedProcessing | When AI response has been parsed into a command |
| Menu | onPause / onUnpause | Menu pause state changes |
| Menu | onReset | Application reset triggered |
| Menu | onExit | User exits to main menu |
| Menu | onError | An application error occurred |
| Menu | onLoadingStarted / onLoadingEnded | Loading operation begins/ends — use to show/hide loading indicators |
| Settings | onVolumeChanged | Master volume slider changed |
| Settings | onQualityChanged | Graphics quality level changed |
| Settings | onSnappingChanged | Snap-to-grid toggled |
| Notification | onNotification | In-world notification displayed |
| VRCanvasUtilities | onBringNearHand | Canvas brought near the user's hand |
Unity Events as shown in the AAXLP manual
Using Your Own 3D Models
-
Open the Manager GameObject in the VR scene
Find the ItemHandler component in the Inspector.
-
Add items to the Items array
Each item entry has three fields:
- Name — must be unique and contain no whitespace
- Type — category label; can be shared across items, but also no whitespace
- Prefab — the 3D prefab to spawn
-
Prepare the prefab correctly
The prefab must have:
- One or more child mesh objects with
MeshRenderer + MeshFilter, or a SkinnedMeshRenderer
- Layer set to Default
- No Collider components on the prefab (AAXLP manages these itself)
-
(Optional) Customise the Boundary Canvas
Edit the Boundary Canvas prefab referenced in ItemHandler to display custom info on items. Do not remove existing elements and do not rename or reorder the four ruler objects.
Every AAXLP script includes description headers in the Inspector. Hovering over variables shows tooltip descriptions — no need to read source code to understand what each field does.
What is this Integration?
The VIROO Integration for VR Builder (D9 package) enables seamless use of VR Builder — a powerful node-based authoring tool for creating interactive VR training scenarios — within VIROO Studio. It replicates VR Builder's core functionality while adding multi-user synchronisation, VIROO interaction system support, and role-based permission management.
Architecture diagram: Unity scene → VR Builder process → VIROO Integration module → multi-user deployment
🏗 Architecture Layers
- Unity layer — scene data + VR Builder process (app logic)
- VR Builder core — Process Editor, Scene Setup Wizard, Behaviors, Conditions, Permission management
- VIROO Integration — connects VR Builder to VIROO; adds custom behaviors (levers, voice), XRI-based interactions, multi-user, permissions
- Extension layer — custom behaviors/conditions/policies you write
System Requirements
| Component | Requirement |
| Unity | Unity 2022.3 LTS or later. Scripting Backend: IL2CPP (recommended) or Mono |
| Render Pipeline | Built-in Render Pipeline only — URP and HDRP are not officially supported with VIROO Studio 2.6 |
| VR Builder | Minimum version 5.3.1 (recommended: latest stable 5.x) |
| VIROO Studio | Template version 2.6 |
| Required packages | VR Builder Core 5.3.1+, Roles and Permissions for VR Builder 1.1.0+, VIROO Integration for VR Builder 1.1.1+ |
| Platforms | Windows PC + tethered VR only. Native standalone Quest builds not supported. |
Installation
-
Set up VIROO Studio 2.6 Template Project
Unzip and open the VIROO Studio 2.6 template project in Unity 2022.
-
Import VR Builder 5.3.1 or later
Import from Unity Asset Store or package file.
- If a Layer 31 overwrite dialog appears → click Skip as many times as needed
- On the last page of the import wizard → untick "Load demo scene" to avoid unnecessary content
-
Disable VR Builder's built-in interaction system
Edit → Project Settings → VR Builder
Untick "Enable built-in interaction component" — you will use the VIROO interaction system instead.
-
Import VR Builder Permission Management package
This is a dependency of the VIROO Integration. Import it before step 5.
-
Import the VIROO Integration for VR Builder package
Import the VIROO Integration package. This completes the setup.
Scene Setup
Creating a New VIROO Scene
-
Open Scene Setup Wizard
Tools → VR Builder → Scene Setup Wizard…
-
Select VIROO as scene type
Choose VIROO from the scene configuration dropdown.
-
Create a new scene (recommended)
For best results create a new scene. If using an existing scene, it must already be VIROO-compatible (the wizard does not apply VIROO-specific changes to existing non-VIROO scenes).
VIROO Scene Requirements (mandatory checklist)
- All GameObjects are parented to the Root object in the Hierarchy
- VR Builder config objects are under Root → VR Builder
- Floor objects are on Layer 8 ("Physics-Floor")
- Every interactable has a Process Scene Object component
- After configuring an object in the Step Inspector: open VIROO Network Object component → click "Generate Object ID"
- Tag
VIROORoot is assigned to the Root GameObject
Important: Whenever an object is dragged into a Step Inspector condition or behavior, you must manually click "Generate Object ID" in its VIROO Network Object component. Without this, objects will not synchronise properly in multi-user sessions.
Process Editor
The Process Editor is the main authoring tool for VR training scenarios. Open it from: Tools → VR Builder → Process Editor or Window → VR Builder → Process Editor
VR Builder Process Editor — Chapters list (left), graph view (right)
Chapters View (left panel)
- Lists all chapters of the process
- Click a chapter to view its graph
- Arrows to reorder, rename, or delete chapters
- Connections foldout shows which chapters lead to/from this one
- Implicit connection: chapter ends with empty transition → next chapter starts automatically
Graph View (right panel)
- Each node is a Step
- Steps contain Behaviors (what happens) and Transitions (where to go next)
- Transitions can have Conditions — only trigger when all conditions are met
- Select a node to edit it in the Step Inspector
- Right-click to create new nodes
Step Inspector — behaviors panel
Transition with conditions
Node Types
Step (default)
The main building block. Empty by default — execution proceeds immediately to the next node. Add Behaviors and Conditions in the Step Inspector to build your logic.
Step Group
A self-contained sub-chapter with its own node graph. Has one input and one output. Double-click to expand. Use to keep the main graph tidy. Create a group by selecting nodes → right-click → Make group.
Step Group node — expandable sub-chapter
Parallel Execution
Runs two or more step sequences simultaneously. Execution continues when all non-optional paths complete. Optional paths are immediately interrupted at that point.
- Non-optional path — continuous arrow icon — must complete
- Optional path — interrupted arrow icon — interrupted when non-optional paths finish (good for looping hints)
- Use the + button to add more paths
Parallel Execution node
Parallel path graph
End Chapter
Immediately ends the current chapter and starts a specific chapter selected from a dropdown. Useful for non-linear processes. Not required for linear processes — an empty transition automatically ends the chapter.
Permission Management
Project Settings → VR Builder → Roles and Permissions
Roles and Permissions panel — enabling and configuring policies
Configuration
- Open: Edit → Project Settings → VR Builder → Roles and Permissions
- Tick "Enforce user role policies" checkbox to activate the system
- Each role has a display name and a unique ID (default: GUID, can be changed to something readable)
- Tick/untick policy checkboxes per role to grant permissions
Assigning Roles
| Component | Location | Behaviour |
SetDefaultUserRoles | Root → VR Builder → PERMISSION_HANDLER | Assigns listed roles to every user that connects to the session |
SetUserRolesOnInteract | Added to any interactable object | Assigns specified roles when user hovers/selects/activates the object. Overwrites existing roles. |
Built-in Policies
| Policy | Description |
| Grab Objects | Allows grabbing any interactable object |
| Touch Objects | Same as above for touch interactions |
| Grab Object Group | Allows grabbing Process Scene Objects assigned to a specific group |
| Touch Object Group | Same as above for touch |
Permission Check (Code)
IPermissionHandler permissionHandler =
RuntimeConfigurator.Configuration.GetPermissionHandler();
// Basic policy check
bool hasPermission = permissionHandler.UserHasPermission<PolicyType>(userId);
// Configurable policy (e.g. object group)
bool hasPermission = permissionHandler
.UserHasPermission<GrabProcessSceneObjectsPolicy, string>(
player.ClientId, objectGroupGuid.ToString());
The user ID is IPlayer.ClientId — accessible from the IPlayer component on the user's rig or via ISessionClientsProvider.
VIROO-Specific Behaviors & Conditions
Find all VIROO-specific items in the VIROO section of the Behaviors and Conditions menus in the Step Inspector.
Execute VIROO Actions — Behavior
Executes the first VIROO action on every referenced object. Useful for VIROO-native functionalities not in the standard VR Builder behavior library. Actions are natively networked — ideal for multi-user apps.
Note: Not all VIROO actions notify when complete. This behavior triggers the action and then deactivates immediately — the step may end right away. Design your process accordingly.
| Parameter | Description |
| TargetObjects | GameObjects containing the action components. Only the first action on each object is executed. |
Grip Button Condition
Completes when the user grips the specified grip button(s).
| Parameter | Description |
| Controls | References to the grip buttons |
| Trigger on release | If checked: completes when button is released. Otherwise: completes as soon as button is gripped. |
| Trigger all controls | If checked: all buttons must be interacted with. Otherwise: only one is needed. |
Pull Lever Condition
Completes when the user pulls the specified lever(s) to a target position.
| Parameter | Description |
| Controls | References to the levers |
| Target position | The desired lever state: true or false |
| Require release | If checked: completes only when lever is released |
| Set all controls | If checked: all levers must reach the target position |
Push Button Condition
Completes when the user pushes the specified button(s).
| Parameter | Description |
| Controls | References to the buttons |
| Trigger on release | If checked: completes when user stops pushing |
| Trigger all controls | If checked: all buttons must be pushed |
Set Slider Condition
Completes when the specified slider(s) are set within a defined range.
| Parameter | Description |
| Controls | References to the sliders |
| Min position | Lower end of the target range (0–1 scale) |
| Max position | Upper end of the target range (0–1 scale) |
| Require release | If checked: completes only when slider is released |
| Set all controls | If checked: all sliders must be in range |
Turn Knob Condition
Completes when the specified knob(s) are set within a defined range.
| Parameter | Description |
| Controls | References to the knobs |
| Min position | Lower end of the target range (0–1 scale) |
| Max position | Upper end of the target range (0–1 scale) |
| Require release | If checked: completes only when knob is released |
| Set all controls | If checked: all knobs must be in range |
Multi-User Limitations
Process runs on the FIRST client only. The VR Builder process starts automatically when the first user joins and runs entirely on that client. If the first client disconnects, the process breaks.
✅ What works in multi-user
- Interactions from other clients are replicated and can advance the process
- Behaviors (text-to-speech, animations) replicated on all clients
- All built-in behaviors and conditions work seamlessly
- VIROO actions are natively networked
⚠️ Current limitations
- Data properties are NOT networked (write only from process side)
- Teleport Condition only works in single-user
- Disconnecting the first client breaks the running process
- Custom code must be designed to handle running on different clients
Best Practices, Testing & Logging
Design Best Practices
- Use VR Builder for the linear step-by-step process (actions the user must perform in order)
- Use VIROO actions and interactions for things that should be interactable at all times (not locked by VR Builder)
- Objects without a Process Scene Object component are never locked by VR Builder — users can always interact with them
- Split processes into logical chapters and step groups to keep graphs manageable
Testing Shortcuts
- To skip to a specific chapter quickly: add an End Chapter node as the very first step, pointing to the target chapter
- Temporarily disconnect steps in the graph to skip sections you don't need to test
- VR Builder Pro users: use menu prefabs to skip steps/chapters at runtime
Verify Setup in Play Mode
Expected console output when pressing Play with a correctly configured VIROO + VR Builder scene
Logging Configuration
Adjust logging granularity in Edit → Project Settings → VR Builder → Logging
VR Builder logging settings window
| State | Meaning |
| Activating | Waiting to execute. A step is executing its behaviors; a chapter is running through its steps. |
| Active | Waiting for user input. A condition is active and waiting to be fulfilled. |
| Deactivating | Finishing up before turning inactive. Most entities deactivate immediately. |
| Inactive | Not currently part of the running process. |
If the process seems stuck, check the log for which condition is in Active state. That condition is not being fulfilled — inspect the referenced object and ensure the interaction is set up correctly.
Update Strategy
When updating VR Builder packages from the Asset Store, remove the package first before re-importing. This prevents conflicts from deleted or renamed files between versions.
Extending VR Builder
Custom behaviors and conditions can be created by extending VR Builder's API.
Production Hall Overview
The learner enters a modern industrial production hall where three robotic tending cells operate in parallel. The environment reflects a realistic manufacturing setup with walkways, safety fencing, and structured material flow.
XR production hall viewed from operator level — fenced robotic cells with 6-axis robot arms, AGV units, and palletised material
Three-cell layout overview
Cell configuration — robots, conveyors, safety fencing
Each Robotic Cell Contains
🦾 Robot & Machine
- 6-axis industrial robot arm
- Configurable process machine:
injection moulding, CNC, or milling
📦 Material Flow
- Infeed and outfeed conveyors
- Palletised raw & finished material
- AGV / HGV units between cells
🚧 Safety Systems
- Safety fencing with mesh panels
- Emergency stop devices
- Restricted & warning zones
- Controlled access gates
- Operator area markings
Three Cell Entry/Exit Configurations (intentional variation for teaching)
| Cell | Configuration | Teaching Purpose |
| Cell 1 | Opposite sides — central alignment | Symmetric flow, equal accessibility from both ends |
| Cell 2 | Opposite corners | Diagonal routing, longer AGV paths |
| Cell 3 | Same-side U-flow | Compact layout, single-direction access |
Learners observe how these layout decisions directly affect accessibility, safety, and workflow efficiency.
Learner Roles
All three roles operate within the same unified production hall:
🔧 Installer
Configures cell layout, places robots and machines, evaluates reach zones.
⚙️ Operator
Executes machine tending cycles, monitors state, handles sequencing errors.
🦺 Safety Supervisor
Identifies hazards, activates e-stops, manages human-robot interaction zones.
Multi-cell production hall — shared logistics infrastructure
Cell detail — material handling and robot workspace
Scenario 1 — XR Layout Planning (AAXLP)
🎯 Objective
Develop spatial reasoning and safe industrial layout configuration skills.
Activities
Compare the three cell entry/exit configurationsObserve how opposite-side, opposite-corner, and U-flow layouts affect operator access and AGV routing.
Adjust robot, machine, and conveyor placementUse the AAXLP drag-and-drop system to reposition factory items. Voice commands supported.
Visualise robot reach and safety zonesView the robot arm reach envelope overlaid on the layout to ensure safe clearances.
Evaluate AGV path routing and workspace clearanceCheck that AGV paths are unobstructed and that operators have clear walkways.
Outcome: Learners understand how layout decisions affect safety, accessibility, and workflow efficiency.
Scenario 2 — Robotic Machine Tending (REACH)
🎯 Objective
Execute a correct machine tending sequence using structured operational logic.
Activities
Verify machine readinessCheck that the process machine is in a ready state before starting the tending cycle.
Perform the robot load/unload cycleFollow the structured VR Builder process to load raw material and unload finished parts.
Monitor machine stateTrack the machine's operational state during processing (running, error, complete).
Transfer finished part to conveyor or AGVComplete the cycle by delivering the finished part to the next stage in the flow.
Respond to incorrect sequencingHandle error states when steps are performed out of order or incorrectly.
Outcome: Learners develop procedural accuracy and operational awareness.
Scenario 3 — Safety & Human–Robot Interaction (HRI)
🎯 Objective
Identify risks and apply safe interaction principles in a robotic cell.
Activities
Detect restricted and warning zonesIdentify the different safety zone types (restricted, warning, collaborative) around each robotic cell.
Observe speed reduction and stop behavioursWatch how the robot responds when a human enters a defined safety zone (speed reduction, full stop).
Activate emergency stopLocate and trigger the emergency stop device. Verify that the robot halts correctly.
Respond to human entry and AGV conflictsHandle scenarios where a person enters a robot workspace or an AGV path is blocked.
Outcome: Learners understand safety fundamentals and hazard mitigation principles in a collaborative robotic environment.
Safety fencing, restricted zones, and operator areas
Human–robot interaction zones with safety indicators
VORAUS Industrial Connection
The XR environment is not limited to visual simulation. It can connect to the VORAUS industrial automation system via WebSocket for real robot control.
VORAUS system connection architecture — VIROO ↔ WebSocket ↔ Industrial control layer
Two Operating Modes
🎮 Simulation Mode (Training)
- Standalone XR environment
- No external system required
- Full robot behaviour simulated locally
- Used for learning and assessment
🔌 Industrial-Connected Mode (Live)
- VIROO connects to VORAUS via WebSocket
- Bidirectional communication with real robot
- Transmits: joint angles, process states
- Receives: motion commands, control signals
- Synchronises robot processes with industrial logic
What the WebSocket Interface Enables
- Real robot control from within the XR environment
- Industrial process monitoring inside XR
- Integration with higher-level automation systems
- Transforms the XR scene from a training tool into a software-driven automation interface
Figure 1: Robot controlled via industrial-level VORAUS system
Figure 2: WebSocket configuration for VORAUS connection
DRAFT NOTICE: These are draft scenarios and learning outcomes. They may change as the project progresses, based on deeper investigation of VIROO, REACH, and AAXLP capabilities.
Scenario 1 — AI-Assisted Industrial Layout Optimisation (AAXLP)
👥 Target Audience
| Field | Detail |
| Job profiles | Industrial engineering students, robotics/automation trainees, production planners, manufacturing engineers |
| EQF level | EQF 4–5 (upper-secondary vocational), EQF 6 (undergraduate), EQF 7–8 (postgraduate/professional) |
| XR experience | None required — onboarding provided |
| Accessibility | Seated/standing, minimal strain, high-contrast visuals, audio support, low motion intensity |
🎯 Learning Objectives
- Design a basic robotic cell layout using AI-assisted tools
- Identify arrangement options and their strengths/weaknesses
- Evaluate AGV routing efficiency and collision risks
- Interpret layout performance indicators (cycle time, space utilisation, travel distance)
- Compare manual vs. AI-recommended layouts
Storyboard — 5 Panels
Panel 1 — Entry
Virtual production hall in miniature planning mode. Voice guidance explains task. Ambient industrial sound. Machines/robots positionable via voice commands.
Panel 2 — Layout Editing
Select machine → it highlights and becomes movable. Red boundary = too close. Green = correct placement.
Panel 3 — AI Suggestion
User activates AI assistance. AI suggests optimal machine and robot positions automatically.
Panel 4 — Simulation
User runs the simulation. AGV paths are visualised, showing safe routing or conflict states.
Panel 5 — Results
Performance panel shows layout status, efficiency score, and safety validation. User adjusts or finishes.
Actions
| Action | Result |
| Enter scene | Factory layout visible in planning mode |
| Move machine | Object repositions with colour-coded safety feedback |
| Activate AI | Layout adjusts automatically to optimal configuration |
| Run simulation | AGV path shows safe routing or conflict state |
| View results | Layout status and performance indicators displayed |
🎮 Pedagogical Approach
- Gamification: scoring on safety and efficiency
- Role: layout engineer testing different cell configurations
- Mode: primarily single-user; future collaborative extensions planned
✅ Evaluation of Success
- Completion of all layout tasks
- Layout passes safety and collision validation
- Performance indicators within target range
Scenario 2 — Robotic Machine Tending (REACH)
👥 Target Audience
| Field | Detail |
| Job profiles | Robot operators, CNC/machine tending technicians, mechatronics trainees, maintenance technicians, automation students |
| EQF level | EQF 4–5 (vocational/technical), EQF 6 (undergraduate), professional upskilling |
| XR experience | None required — guided onboarding included |
| Accessibility | Seated/standing, limited movement, clear visual/audio, minimal motion effects |
🎯 Learning Objectives
- Execute the correct machine start-up and shutdown sequence
- Load and unload parts following safe operational procedures
- Recognise incorrect workflow steps and apply corrective actions
- Identify interlock dependencies (e.g., door must be closed before cycle start)
- Respond appropriately to emergency stop events
- Complete a full robotic machine tending cycle without safety violations
Storyboard — 5 Panels
Panel 1 — Entry & Mode Select
Robot and machine inactive. Panel offers: Local Control (VIROO) or VORAUS Core Control. User selects mode before continuing.
Panel 2 — Initialisation
User pulls the power lever. System activates. VORAUS mode shows a live connection indicator.
Panel 3 — Load Part
User grabs the raw part and places it inside the machine. Correct placement is visually confirmed (green highlight).
Panel 4 — Start Cycle
User presses cycle start. Robot and machine begin operating. Emergency stop halts everything immediately.
Panel 5 — Completion
User unloads the finished part. Summary panel shows task status, cycle time, and procedural compliance.
Actions
| Action | Result |
| Select control mode | System runs in Local (VIROO) or VORAUS mode |
| Power on (pull lever) | Machine activates |
| Load part | Part placed inside machine; placement visually confirmed |
| Start cycle | Robot and machine begin operating |
| Emergency stop | Operation stops immediately; alarm sounds |
| Unload part | Cycle completes; summary panel appears |
🎮 Pedagogical Approach
- Gamification: feedback on procedural accuracy and task completion
- Role: machine operator following operational steps
- Mode: primarily single-user; role-based extensions possible
✅ Evaluation of Success
- Correct sequence execution without skipping steps
- No safety violations during operation
- Successful completion of the full production cycle
Scenario 3 — Safety & Human–Robot Interaction (HRI)
👥 Target Audience
| Field | Detail |
| Job profiles | Safety officers, robot operators, production supervisors, mechatronics technicians, engineering students |
| EQF level | EQF 4–5 (vocational/technical), EQF 6 (undergraduate), EQF 7 (professional safety/industrial upskilling) |
| XR experience | None required — onboarding provided |
| Accessibility | Low physical strain, colour-coded zone visuals, audio guidance, minimal motion, step-based progression |
🎯 Learning Objectives
- Recognise safety zones around a robot (🟢 green / 🟡 yellow / 🔴 red)
- Understand how robot behaviour changes based on human proximity
- Trigger and reset an emergency stop following correct protocol
- Identify unsafe zone intrusion scenarios
- Apply correct restart procedure after a safety interruption
- Demonstrate safe interaction within a human-robot collaborative workspace
Safety Zone Model
| Zone | Colour | Robot Behaviour |
| Collaborative zone | 🟢 Green | Robot operates normally at full speed |
| Warning zone | 🟡 Yellow | Robot slows down; soft warning sound plays |
| Restricted zone | 🔴 Red | Robot stops immediately; red indicator activates |
Storyboard — 5 Panels
Panel 1 — Safety Zones
User stands near collaborative robot. Green, yellow, and red zones visible on floor. Robot operates normally.
Panel 2 — Yellow Zone Entry
User steps into yellow zone → robot slows down. Soft warning sound plays.
Panel 3 — Red Zone Entry
User steps into red zone → robot stops completely. Red indicator light activates.
Panel 4 — Emergency Stop
User presses emergency stop. Alarm sounds. Robot remains halted until reset procedure is completed.
Panel 5 — Reset & Resume
User enters cell, removes grasped parts, manually moves robot to safe start point, restarts process. Robot resumes. Safety summary appears.
Actions
| Action | Result |
| Enter yellow zone | Robot slows down |
| Enter red zone | Robot stops completely |
| Press emergency stop | Alarm activates and system halts |
| Reset system | Robot resumes operation after reset procedure |
| Complete session | Safety performance feedback displayed |
🎮 Pedagogical Approach
- Gamification: safety awareness feedback and performance indicators
- Role: guided role-play within a collaborative robotic workspace
- Mode: primarily single-user; option to simulate multiple roles
✅ Evaluation of Success
- Correct identification and response to each zone type
- Appropriate reactions to zone intrusions and emergency events
- Correct completion of the safety reset procedure