Unigine Engine

https://github.com/wookiee/unigine_docs
Admin
Unigine Engine is a real-time 3D engine for creating interactive applications, games, and...
Tokens:168,325
Snippets:438
Trust Score:2
Update:8 months ago
Show doc for...
Tokens:
Raw
### Setup FFB UI for Joysticks (C#)

Source: https://github.com/wookiee/unigine_docs/blob/main/Csharp_Components.md

This method sets up the user interface for force feedback effects on a joystick. It iterates through available FFB effect types and creates corresponding UI elements using the CreateFfbEffectUi helper function. Dependencies include JoystickInfo, Widget, and InputJoystickComponent.

```csharp
private void SetupFfbUi(JoystickInfo joystickInfo, Widget parent, InputJoystickComponent joystickComponent)
{
	var scroll = new WidgetScrollBox() { Width = 325, Height = 200 };
	scroll.HScrollEnabled = false;
	parent.AddChild(scroll, Gui.ALIGN_EXPAND);
	foreach (var effectType in joystickInfo.FfbData.AvailableFfbEffects)
	{
		switch (effectType)
		{
			case FfbEffectType.JOYSTICK_FORCE_FEEDBACK_CONSTANT:
				CreateFfbEffectUi("Constant", joystickComponent, scroll, joystickInfo, effectType, true, false,
					false);
				break;
			case FfbEffectType.JOYSTICK_FORCE_FEEDBACK_RAMP:
				CreateFfbEffectUi("Ramp", joystickComponent, scroll, joystickInfo, effectType, true, false,
					true);
				break;
			case FfbEffectType.JOYSTICK_FORCE_FEEDBACK_SINEWAVE:
				CreateFfbEffectUi("Sine Wave", joystickComponent, scroll, joystickInfo, effectType, true, true,
					false);
				break;
			case FfbEffectType.JOYSTICK_FORCE_FEEDBACK_SQUAREWAVE:
				CreateFfbEffectUi("Square Wave", joystickComponent, scroll, joystickInfo, effectType, true,
					true, false);
				break;
			case FfbEffectType.JOYSTICK_FORCE_FEEDBACK_TRIANGLEWAVE:
				CreateFfbEffectUi("Triangle Wave", joystickComponent, scroll, joystickInfo, effectType, true,
					true, false);
				break;
			case FfbEffectType.JOYSTICK_FORCE_FEEDBACK_SAWTOOTHUPWAVE:
				CreateFfbEffectUi("Saw Tooth Up", joystickComponent, scroll, joystickInfo, effectType, true, true,
					false);
				break;
			case FfbEffectType.JOYSTICK_FORCE_FEEDBACK_SAWTOOTHDOWNWAVE:
				CreateFfbEffectUi("Saw Tooth Down", joystickComponent, scroll, joystickInfo, effectType, true, true,
					false);
				break;
			case FfbEffectType.JOYSTICK_FORCE_FEEDBACK_SPRING:
				CreateFfbEffectUi("Spring", joystickComponent, scroll, joystickInfo, effectType, false, false,
					false);
				break;
			case FfbEffectType.JOYSTICK_FORCE_FEEDBACK_FRICTION:
				CreateFfbEffectUi("Friction", joystickComponent, scroll, joystickInfo, effectType, false, false,
					false);
				break;
			case FfbEffectType.JOYSTICK_FORCE_FEEDBACK_DAMPER:
				CreateFfbEffectUi("Damper", joystickComponent, scroll, joystickInfo, effectType, false, false,
					false);
				break;
			case FfbEffectType.JOYSTICK_FORCE_FEEDBACK_INERTIA:
				CreateFfbEffectUi("Inertia", joystickComponent, scroll, joystickInfo, effectType, false, false,
					false);
				break;
			case FfbEffectType.NUM_JOYSTICK_FORCE_FEEDBACKS:
			default:
				throw new ArgumentOutOfRangeException(nameof(joystickInfo));
		}
	}
}
```

--------------------------------

### Unigine Console Command Handling (C#)

Source: https://github.com/wookiee/unigine_docs/blob/main/Csharp_Components.md

Shows how to add, remove, and run console commands within an Unigine application using C#. It includes examples of a basic command callback and a command to control a node's position.

```csharp
using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using Unigine;
using static Unigine.Console;
[Component(PropertyGuid = "4a09e0b28e49cc455a0eb7d09be530dfd3a97092")]
public class ConsoleSample : Component
{
	public Node controllable_node;
	void Init()
	{
		// show console
		Unigine.Console.Active = true;
		// here we add a new console command and add callback to process this command from our c# code
		Unigine.Console.AddCommand("my_console_command", "my_console_command decription", command_callback);
		// run console command
		Unigine.Console.Run("my_console_command \"Hello from C++\"
");
		Unigine.Console.AddCommand("control_node", "With this command you can control node, pass desired position through the arguments",
		 move_node_callback);
		if (!controllable_node)
		{
			Log.Message("ConsoleSample.Init(): No node was provided!\n");
		}
		Log.Message("To move the node, you can use control_node command and 3 arguments to specify node position\n");
	}
	void Shutdown()
	{
		Unigine.Console.RemoveCommand("my_console_command");
		Unigine.Console.RemoveCommand("control_node");
		Unigine.Console.Active = false;
	}
	private void command_callback(int argc, string[] argv)
	{
		Log.Message("my_console_command(): called\n");
		for (int i = 0; i < argc; i++)
			Log.Message("{0}: {1}\n", i, argv[i]);
	}
	private void move_node_callback(int argc, string[] argv)
	{
		if (!controllable_node)
			return;
		vec3 node_position = new vec3();
		if (argc != 4)
		{
			Log.Warning("control_node was called incorrectly, you need to pass 3 coordinates to move the node\n");
			return;
		}
		var parse_arg = (int index) =>
		{
			string a_value = argv[index];
			bool is_number = float.TryParse(a_value, NumberStyles.Any, CultureInfo.InvariantCulture, out float res);
			float value = is_number ? res : 0.0f;
			return value;
		};
		node_position.x = parse_arg(1);
		node_position.y = parse_arg(2);
		node_position.z = parse_arg(3);
		controllable_node.WorldPosition = node_position;
	}
};

```

--------------------------------

### Create and Manage Icon Widget in C#

Source: https://github.com/wookiee/unigine_docs/blob/main/Csharp_Components.md

Shows how to create and manage an icon widget in Unigine using C#. This example covers initializing the icon with an image, setting its size and position, making it toggleable, and handling click events. The icon is added to the GUI during initialization and removed during shutdown.

```csharp
using Unigine;
[Component(PropertyGuid = "18ecb4706f48bd0f54eb8722968e5c1998cc96a4")]
public class WidgetsIcon : Component
{
	public int x = 500;
	public int y = 450;
	public int width = 32;
	public int height = 32;
	[ParameterFile]
	public string iconImage = "";
	private WidgetIcon icon = null;
	private void Init()
	{
		Gui gui = Gui.GetCurrent();
		// create icon
		icon = new WidgetIcon(gui, iconImage, width, height);
		icon.Toggleable = true;
		icon.SetPosition(x, y);
		icon.EventClicked.Connect(() => Unigine.Console.OnscreenMessageLine($"Icon: {icon.Toggled}"));
		// add icon to current gui
		gui.AddChild(icon, Gui.ALIGN_OVERLAP);
		Unigine.Console.Onscreen = true;
	}
	private void Shutdown()
	{
		// remove icon from current gui
		Gui.GetCurrent().RemoveChild(icon);
		Unigine.Console.Onscreen = false;
	}
}
```

--------------------------------

### Create and Manage Listbox Widget in C#

Source: https://github.com/wookiee/unigine_docs/blob/main/Csharp_Components.md

Illustrates how to create and manage a listbox widget in Unigine using C#. This example shows adding items to the listbox, setting its position and font size, and handling the item selection event. The listbox is added to the GUI on initialization and removed on shutdown.

```csharp
using Unigine;
[Component(PropertyGuid = "0b957b466bfa19ede69bb268679472a7d6f64fda")]
public class WidgetsListbox : Component
{
	public int x = 300;
	public int y = 300;
	public int fontSize = 16;
	private WidgetListBox listBox = null;
	private void Init()
	{
		Gui gui = Gui.GetCurrent();
		// create listbox
		listBox = new WidgetListBox(gui);
		listBox.SetPosition(x, y);
		listBox.AddItem("item 0");
		listBox.AddItem("item 1");
		listBox.AddItem("item 2");
		listBox.FontSize = fontSize;
		listBox.FontOutline = 1;
		listBox.EventChanged.Connect(() => Unigine.Console.OnscreenMessageLine($"Listbox: {listBox.GetCurrentItemText()}"));
		// add listbox to current gui
		gui.AddChild(listBox, Gui.ALIGN_OVERLAP);
		Unigine.Console.Onscreen = true;
	}
	private void Shutdown()
	{
		// remove listbox from current gui
		Gui.GetCurrent().RemoveChild(listBox);
		Unigine.Console.Onscreen = false;
	}
}
```

--------------------------------

### Initialize FMOD Plugin and Load Banks in C#

Source: https://github.com/wookiee/unigine_docs/blob/main/Csharp_Components.md

This C# code initializes the FMOD plugin for Unigine, checks for its availability, and loads necessary sound banks. It handles potential errors if the plugin is not found, displaying an informative message to the user. This setup is crucial for enabling FMOD audio functionalities within the engine.

```csharp
using Unigine;
using Unigine.Plugins.FMOD;
using System;
#if UNIGINE_DOUBLE
using Vec3 = Unigine.dvec3;
using Vec4 = Unigine.dvec4;
using Mat4 = Unigine.dmat4;
#else
using Vec3 = Unigine.vec3;
using Vec4 = Unigine.vec4;
using Mat4 = Unigine.mat4;
#endif

[Component(PropertyGuid = "5cb85699ce485ecd4f4c9e8bead8eb7993f5d703")]
public class FMODStudioSample : Component
{
	private bool pluginInitialized = false;

	void Init()
	{
		// load the FMOD plugin
		if (Engine.FindPlugin("UnigineFMOD") == -1)
			Engine.AddPlugin("UnigineFMOD");

		if (!FMOD.CheckPlugin())
		{
			// Handle plugin not found error
			return;
		}

		pluginInitialized = true;

		// initialize FMOD Studio and load sound banks
		FMODStudio studio = FMOD.Studio;
		studio.UseStudioLiveUpdateFlag();
		studio.InitStudio();
		studio.LoadBank(FileSystem.GetAbsolutePath(FileSystem.ResolvePartialVirtualPath("fmod_studio/fmod_banks/Master.bank")));
		studio.LoadBank(FileSystem.GetAbsolutePath(FileSystem.ResolvePartialVirtualPath("fmod_studio/fmod_banks/Master.strings.bank")));
		studio.LoadBank(FileSystem.GetAbsolutePath(FileSystem.ResolvePartialVirtualPath("fmod_studio/fmod_banks/Vehicles.bank")));
		studio.LoadBank(FileSystem.GetAbsolutePath(FileSystem.ResolvePartialVirtualPath("fmod_studio/fmod_banks/SFX.bank")));
	}
}
```

--------------------------------

### Unigine Update Methods Example (C#)

Source: https://github.com/wookiee/unigine_docs/blob/main/Csharp_Components.md

Demonstrates the usage of various Unigine update methods like MyUpdate, MyPostUpdate, MyUpdatePhysics, MySwap, and MyShutdown. These methods are called at different stages of the Unigine engine's lifecycle and can be ordered using attributes.

```csharp
private void MyUpdate()
{
	Log.Message("MyUpdate\n");
}
// Using the MethodPostUpdate attribute, you can create any number of PostUpdate methods
[MethodPostUpdate(Order = 1)]
private void MyPostUpdate()
{
	Log.Message("MyPostUpdate\n");
}
// Using the MethodUpdatePhysics attribute, you can create any number of UpdatePhysics methods
[MethodUpdatePhysics(Order = 1)]
private void MyUpdatePhysics()
{
	Log.Message("MyUpdatePhysics\n");
}
// Using the MethodSwap attribute, you can create any number of Swap methods
[MethodSwap(Order = 1)]
private void MySwap()
{
	Log.Message("MySwap\n");
}
// Using the MethodShutdown attribute, you can create any number of Shutdown methods
[MethodShutdown(Order = 1)]
private void MyShutdown()
{
	Log.Message("MyShutdown\n");
}
```

--------------------------------

### Create and Manage Edittext Widget in C#

Source: https://github.com/wookiee/unigine_docs/blob/main/Csharp_Components.md

Provides a C# example for creating and managing a multi-line text input field (Edittext) in Unigine. This includes initializing the widget, setting its position, dimensions, font size, and handling the text change event. The widget is added to the GUI on initialization and removed on shutdown.

```csharp
using Unigine;
[Component(PropertyGuid = "00ce6ffe7757d74551675fe0ebc211bf4402f412")]
public class WidgetsEdittext : Component
{
	public int x = 250;
	public int y = 150;
	public int width = 150;
	public int height = 100;
	public string text = "Enter text...";
	public int fontSize = 16;
	private WidgetEditText editText = null;
	private void Init()
	{
		Gui gui = Gui.GetCurrent();
		// create edittext
		editText = new WidgetEditText(gui, text);
		editText.SetPosition(x, y);
		editText.Width = width;
		editText.Height = height;
		editText.FontSize = fontSize;
		editText.FontOutline = 1;
		editText.EventChanged.Connect(() => Unigine.Console.OnscreenMessageLine($"Edittext: {editText.Text}"));
		// add edittext to current gui
		gui.AddChild(editText, Gui.ALIGN_OVERLAP);
		Unigine.Console.Onscreen = true;
	}
	private void Shutdown()
	{
		// remove edittext from current gui
		Gui.GetCurrent().RemoveChild(editText);
		Unigine.Console.Onscreen = false;
	}
}
```

--------------------------------

### Play 3D Music - UnigineScript

Source: https://github.com/wookiee/unigine_docs/blob/main/Csharp_Components.md

Starts 3D music playback at a specified world position (carSphere.WorldPosition). It stops any existing 3D music playback before starting the new one. Requires valid music channel and sound objects.

```UnigineScript
void PlayMusic3D()
	{
		// start 3D music playback at the car_sphere position
		if (!musicChannel || !musicChannel.IsPlaying)
		{
			StopMusic3D();
			musicChannel3D = musicSound3D.Play();
			musicChannel3D.SetPosition(carSphere.WorldPosition);
		}
```

--------------------------------

### Initialize FMOD Core and Load Sounds in C#

Source: https://github.com/wookiee/unigine_docs/blob/main/Csharp_Components.md

This C# code initializes the FMOD audio plugin, sets up the FMOD core with a specified number of channels, and loads both 2D and 3D sound files. It includes error handling for plugin detection and provides a fallback UI element if the plugin is not found. The script also creates a visual representation for the 3D sound source.

```csharp
using System;
using Unigine;
using Unigine.Plugins.FMOD;
[Component(PropertyGuid = "95d526786760889d8859911ec8ef8bf20e579a00")]
public class FMODCoreSample : Component
{
	private bool pluginInitialized = false;
	private ObjectMeshDynamic carSphere = null;
	private Unigine.Plugins.FMOD.Sound musicSound = null;
	private Unigine.Plugins.FMOD.Sound musicSound3D = null;
	private Channel musicChannel = null;
	private Channel musicChannel3D = null;
	private SampleDescriptionWindow sampleDescriptionWindow = null;
	private WidgetSlider musicPositionSlider;
	private WidgetSlider distortionSlider;
	private WidgetSlider volumeSlider;

	void Init()
	{
		sampleDescriptionWindow = new SampleDescriptionWindow();
		sampleDescriptionWindow.createWindow(Gui.ALIGN_LEFT, 500);
		// load the FMOD plugin
		if (Engine.FindPlugin("UnigineFMOD") == -1)
			Engine.AddPlugin("UnigineFMOD");
		if (!FMOD.CheckPlugin())
		{
			WidgetGroupBox parametersGroupbox = sampleDescriptionWindow.getParameterGroupBox();
			var infoLabel = new WidgetLabel();
			infoLabel.FontWrap = 1;
			infoLabel.Text = "Cannot find FMOD plugin. Please check UnigineFMOD and fmod.dll, fmodL.dll, fmodstudio.dll, fmodstudioL.dll (You can download these files from official site) in bin directory.";
			parametersGroupbox.AddChild(infoLabel);
			return;
		}
		pluginInitialized = true;
		// initialize FMOD Core with 1024 channels in NORMAL mode
		FMODCore core = FMOD.Core;
		core.InitCore(1024, FMODEnums.INIT_FLAGS.NORMAL);
		// load a 2D sound file
		musicSound = core.CreateSound(
			FileSystem.GetAbsolutePath(FileSystem.ResolvePartialVirtualPath("fmod_core/sounds/soundtrack.oga")),
			FMODEnums.FMOD_MODE._2D);
		// load the same file as a 3D sound
		musicSound3D = core.CreateSound(
			FileSystem.GetAbsolutePath(FileSystem.ResolvePartialVirtualPath("fmod_core/sounds/soundtrack.oga")),
			FMODEnums.FMOD_MODE._3D);
		// create a sphere to visualize the 3D sound source
		carSphere = Primitives.CreateSphere(1.0f);
		carSphere.SetMaterialParameterFloat4("albedo_color", new vec4(0.4f, 0.0f, 0.0f, 1.0f), 0);
		Visualizer.Enabled = true;
		InitDescriptionWindow();
	}
// ... other methods ...
}
```

--------------------------------

### Multiple Initialization Methods with MethodInit

Source: https://github.com/wookiee/unigine_docs/blob/main/Csharp_Components.md

Demonstrates how to define multiple initialization methods using the MethodInit attribute. The Order parameter controls the execution sequence of these methods during component initialization.

```csharp
// Using the MethodInit attribute, you can create any number of Init methods
[MethodInit(Order = 1)]
private void MyInit()
{
	Log.Message("MyInit\n");
}
```

--------------------------------

### Play 2D Music - UnigineScript

Source: https://github.com/wookiee/unigine_docs/blob/main/Csharp_Components.md

Starts 2D music playback, adding a distortion DSP effect and setting the volume. It stops any existing 2D music playback before starting the new one. Requires valid music channel and sound objects.

```UnigineScript
void PlayMusic()
	{
		// start 2D music playback if 3D music is not playing
		// adds a distortion DSP effect and sets the volume
		if (!musicChannel3D || !musicChannel3D.IsPlaying)
		{
			StopMusic();
			musicChannel = musicSound.Play();
			musicChannel.AddDSP(0, DSPType.TYPE.DISTORTION).SetParameterFloat(0, distortionSlider.Value * 0.01f);
			musicChannel.Volume = volumeSlider.Value * 0.01f;
		}
```

--------------------------------

### Component Lifecycle Method: OnReady

Source: https://github.com/wookiee/unigine_docs/blob/main/Csharp_Components.md

This method is automatically called by the UNIGINE Engine when the component is initialized and ready for use. It's a common place for initial setup tasks.

```csharp
// This method is called by the Engine, when the component is ready for initialization
protected override void OnReady()
{
	Log.Message("OnReady\n");
}
```

--------------------------------

### ParameterMaterial for Material References

Source: https://github.com/wookiee/unigine_docs/blob/main/Csharp_Components.md

Shows how to use the ParameterMaterial attribute to assign a Material asset. The ParentGUID parameter can be used to specify a parent material or a specific material GUID.

```csharp
// you can use the ParameterMaterial for Material
[ParameterMaterial(ParentGUID = "83eb006a9be234c16ec9872c5bd2589b5c8e353e")]
public Material material;
```

--------------------------------

### Initialize Microprofiler Sample Component in C#

Source: https://github.com/wookiee/unigine_docs/blob/main/Csharp_Components.md

Initializes the MicroprofilerSample component, checks for Microprofiler availability, and sets up a description window. It configures the engine's background update mode and displays a warning if the Microprofiler is not compiled.

```csharp
using Unigine;
[Component(PropertyGuid = "0bf2c8c22c3dc582e4207a776cee495b07b0b055")]
public class MicroprofilerSample : Component
{
	private Engine.BACKGROUND_UPDATE previous_bg_update = Engine.BACKGROUND_UPDATE.BACKGROUND_UPDATE_DISABLED;
	private SampleDescriptionWindow sampleDescriptionWindow = new();
	void Init()
	{	
		string description;
		if (Profiler.MicroprofileUrl == "")
		{
			WindowManager.DialogError("Warning", "Microprofiler is not available!");
			description = "<font color=\"#de4a14\"><p>Microprofiler is not compiled.</p><p>Use development-release binaries.</p></font>";
		}
		else
		{
			description = "<p>Microprofiler url <font color=\"#de4a14\">" + Profiler.MicroprofileUrl + "</font></p>";
		}
		sampleDescriptionWindow.createWindow();
		WidgetLabel label = new(description)
		{
			FontRich = 1,
			FontWrap = 1,
			Width = 300
		};
		sampleDescriptionWindow.getParameterGroupBox().AddChild(label, Gui.ALIGN_LEFT);
		previous_bg_update = Engine.BackgroundUpdate;
		Engine.BackgroundUpdate = Engine.BACKGROUND_UPDATE.BACKGROUND_UPDATE_RENDER_NON_MINIMIZED;		
	}

	void Shutdown()
	{
		Engine.BackgroundUpdate = previous_bg_update;
		sampleDescriptionWindow.shutdown();
	}
}
```

--------------------------------

### Navigation Sector Visualization in C#

Source: https://github.com/wookiee/unigine_docs/blob/main/Csharp_Components.md

Enables the visualization of a NavigationSector within the Unigine engine. It initializes by getting the NavigationSector component and enables the visualizer. The Update method continuously renders the visualizer.

```csharp
using Unigine;
[Component(PropertyGuid = "095d1febeed4344e05aaaf55a742b8b05998744f")]
public class NavigationSectorVisualizer : Component
{
	private NavigationSector navigationSector = null;
	private void Init()
	{
		navigationSector = node as NavigationSector;
		if (navigationSector)
			Visualizer.Enabled = true;
	}
	private void Update()
	{
		if (navigationSector)
			navigationSector.RenderVisualizer();
	}
	private void Shutdown()
	{
		Visualizer.Enabled = false;
	}
}
```

--------------------------------

### Initialize InputGamepadUI Component (C#)

Source: https://github.com/wookiee/unigine_docs/blob/main/Csharp_Components.md

Initializes the InputGamepadUI component, setting up mouse handling, creating UI elements from specified files, and subscribing to gamepad events. It requires UI definition files for the main interface and gamepad info.

```csharp
using System;
using System.Collections.Generic;
using Unigine;
[Component(PropertyGuid = "740808362162e21d6960fcd8ec31da576a74b3ca")]
public class InputGamepadUI : Component
{
	public InputGamePadComponent gamepadComponent = null;
	[ParameterFile(Filter = ".ui")]
	public string uiFile = null;
	[ParameterFile(Filter = ".ui")]
	public string uiInfoFile = null;
	static public event Action<int, float> filterChanged;
	static public event Action<int, float, float, float> setVibration;
	private class InfoWidgets
	{
		public WidgetVBox infoVBox = null;
		public WidgetLabel nameLabel = null;
		public WidgetLabel numberLabel = null;
		public WidgetLabel playerIndexLabel = null;
		public WidgetLabel deviceTypeLabel = null;
		public WidgetLabel modelTypeLabel = null;
		public WidgetLabel availableLabel = null;
		public WidgetSlider filterSlider = null;
		public WidgetLabel lastButtonDownLabel = null;
		public WidgetLabel lastButtonPressedLabel = null;
		public WidgetLabel lastButtonUpLabel = null;
		public WidgetLabel leftAxesXLabel = null;
		public WidgetLabel leftAxesYLabel = null;
		public WidgetLabel rightAxesXLabel = null;
		public WidgetLabel rightAxesYLabel = null;
		public WidgetLabel leftLastDeltaXLabel = null;
		public WidgetLabel leftLastDeltaYLabel = null;
		public WidgetLabel rightLastDeltaXLabel = null;
		public WidgetLabel rightLastDeltaYLabel = null;
		public WidgetLabel leftTriggerLabel = null;
		public WidgetLabel rightTriggerLabel = null;
		public WidgetLabel lastLeftTriggerDeltaLabel = null;
		public WidgetLabel lastRightTriggerDeltaLabel = null;
		public WidgetSlider lowFrequencySlider = null;
		public WidgetSlider highFrequencySlider = null;
		public WidgetSlider durationSlider = null;
		public WidgetButton vibrationButton = null;
		public WidgetCanvas touchpadCanvas = null;
	}
	private UserInterface ui = null;
	private List<UserInterface> infosUi = null;
	private List<InfoWidgets> infoWidgets = null;
	private WidgetHBox mainHBox = null;
	private WidgetVBox backgroundVBox = null;
	private WidgetLabel errorMessageLabel = null;
	private WidgetVBox generalMessageInfo = null;
	private WidgetLabel countGamepadsLabel = null;
	private WidgetLabel countActiveGamepadsLabel = null;
	private WidgetHBox gamepadsInfoBox = null;
	private int lastGamepadsCount = 0;
	[MethodInit(Order = -1)]
	private void Init()
	{
		Input.MouseHandle = Input.MOUSE_HANDLE.USER;
		infosUi = new List<UserInterface>();
		infoWidgets = new List<InfoWidgets>();
		Gui gui = Gui.GetCurrent();
		ui = new UserInterface(gui, uiFile);
		InitWidget(nameof(mainHBox), out mainHBox, ui);
		InitWidget(nameof(backgroundVBox), out backgroundVBox, ui);
		InitWidget(nameof(errorMessageLabel), out errorMessageLabel, ui);
		InitWidget(nameof(generalMessageInfo), out generalMessageInfo, ui);
		InitWidget(nameof(countGamepadsLabel), out countGamepadsLabel, ui);
		InitWidget(nameof(countActiveGamepadsLabel), out countActiveGamepadsLabel, ui);
		InitWidget(nameof(gamepadsInfoBox), out gamepadsInfoBox, ui);
		gui.AddChild(mainHBox);
		backgroundVBox.BackgroundColor = new vec4(0.0f, 0.0f, 0.0f, 0.5f);
		gamepadComponent.onTouch += DrawTouchInfo;
	}
	private void Update()
	{
		if (gamepadComponent == null)
			return;
		// update ui for current gamepads
		if (lastGamepadsCount != gamepadComponent.CountActiveGamePads)
		{
			UpdateUI();
			lastGamepadsCount = gamepadComponent.CountActiveGamePads;
		}
		// show information about gamepads
		for (int i = 0; i < gamepadComponent.CountActiveGamePads; i++)
		{
			infoWidgets[i].nameLabel.Text = gamepadComponent.GamepadsInfo[i].name;
			infoWidgets[i].deviceTypeLabel.Text = gamepadComponent.GamepadsInfo[i].deviceType.ToString();
			infoWidgets[i].modelTypeLabel.Text = gamepadComponent.GamepadsInfo[i].modelType.ToString();
			infoWidgets[i].playerIndexLabel.Text = gamepadComponent.GamepadsInfo[i].playerIndex.ToString();
			infoWidgets[i].availableLabel.Text = gamepadComponent.GamepadsInfo[i].isAvailable.ToString();
			infoWidgets[i].lastButtonDownLabel.Text = gamepadComponent.GamepadsInfo[i].lastButtonDown?.ToString();
			infoWidgets[i].lastButtonPressedLabel.Text = gamepadComponent.GamepadsInfo[i].lastButtonPressed?.ToString();
			infoWidgets[i].lastButtonUpLabel.Text = gamepadComponent.GamepadsInfo[i].lastButtonUp?.ToString();
			infoWidgets[i].leftAxesXLabel.Text = gamepadComponent.GamepadsInfo[i].axesLeft.x.ToString("0.000");
			infoWidgets[i].leftAxesYLabel.Text = gamepadComponent.GamepadsInfo[i].axesLeft.y.ToString("0.000");
			infoWidgets[i].rightAxesXLabel.Text = gamepadComponent.GamepadsInfo[i].axesRight.x.ToString("0.000");
			infoWidgets[i].rightAxesYLabel.Text = gamepadComponent.GamepadsInfo[i].axesRight.y.ToString("0.000");
			infoWidgets[i].leftLastDeltaXLabel.Text = gamepadComponent.GamepadsInfo[i].axesLeftLastDelta.x.ToString("0.000");

```

--------------------------------

### Initialize UNIGINE Engine and Start Main Loop (C#)

Source: https://context7.com/wookiee/unigine_docs/llms.txt

Initializes the UNIGINE engine with version and arguments, then enters the main application loop to handle rendering, physics, and logic updates. Ensures a clean shutdown of the engine resources.

```csharp
using Unigine;

class UnigineApp
{
    [STAThread]
    static void Main(string[] args)
    {
        // Initialize the engine with version check and command-line arguments
        Engine engine = Engine.Init(Engine.VERSION, args);

        // Enter the main application loop
        // This handles all rendering, physics, and logic updates
        engine.Main();

        // Clean shutdown of the engine
        Engine.Shutdown();
    }
}
```

--------------------------------

### Navigation Mesh Visualization in C#

Source: https://github.com/wookiee/unigine_docs/blob/main/Csharp_Components.md

Enables the visualization of a NavigationMesh within the Unigine engine. It initializes by getting the NavigationMesh component and enables the visualizer. The Update method continuously renders the visualizer.

```csharp
using Unigine;
[Component(PropertyGuid = "a556356231a6b559e3d89ee4a201dcf3c84afdb6")]
public class NavigationMeshVisualizer : Component
{
	private NavigationMesh navigationMesh = null;
	private void Init()
	{
		navigationMesh = node as NavigationMesh;
		if (navigationMesh)
			Visualizer.Enabled = true;
	}
	private void Update()
	{
		if (navigationMesh)
			navigationMesh.RenderVisualizer();
	}
	private void Shutdown()
	{
		Visualizer.Enabled = false;
	}
}
```

--------------------------------

### Initialize GUI Elements

Source: https://github.com/wookiee/unigine_docs/blob/main/Csharp_Components.md

This function initializes the graphical user interface for the sample. It creates a description window and a parameter group box, then adds a grid box to hold UI elements like labels and combo boxes for thread selection.

```csharp
private void InitGui()
{
	sampleDescriptionWindow = new SampleDescriptionWindow();
	sampleDescriptionWindow.createWindow(Gui.ALIGN_RIGHT);
	var params_box = sampleDescriptionWindow.getParameterGroupBox();
	var gridbox = new WidgetGridBox(2, 10);
	params_box.AddChild(gridbox, Gui.ALIGN_EXPAND);
	var label = new WidgetLabel("Thread");
	gridbox.AddChild(label, Gui.ALIGN_LEFT);
	threadCombo = new WidgetComboBox();
}
```

--------------------------------

### Get Velocity Acceleration (C#)

Source: https://github.com/wookiee/unigine_docs/blob/main/Csharp_Components.md

This C# method calculates the velocity acceleration by multiplying the current velocity by a predefined acceleration multiplier. This value is used to set the maximum velocity for the spectator player.

```csharp
float GetVelocityAcceleration()
{
	return GetVelocity() * accelerationMultiplier;
}
```

--------------------------------

### Unigine Get Node Under Cursor

Source: https://github.com/wookiee/unigine_docs/blob/main/Csharp_Components.md

Performs a raycast from the player's camera through the mouse cursor's position to detect the first intersected object within a specified distance. This is used for object selection.

```csharp
private Unigine.Object GetNodeUnderCursor()
	{
		Player player = Game.Player;
		ivec2 mouse = Input.MousePosition;
		// returns the first object intersected by the ray casted from the player in the forward direction at a distance of 10000 units
		return World.GetIntersection(player.WorldPosition, player.WorldPosition + new Vec3(player.GetDirectionFromMainWindow(mouse.x, mouse.y) * 10000), intersectionMask);
	}
```

--------------------------------

### Initialize Gamepad UI Widgets

Source: https://github.com/wookiee/unigine_docs/blob/main/Csharp_Components.md

Initializes and adds UI elements for each active gamepad. This includes creating new UserInterface instances, setting up various labels and sliders, and connecting event handlers for filter sliders and vibration buttons. It dynamically builds the UI based on connected gamepads.

```csharp
// remove current ui with gamepads information
for (int i = 0; i < infosUi.Count; i++)
{
	mainHBox.RemoveChild(infosUi[i].GetWidget(0));
	infosUi[i].DeleteLater();
}
infosUi.Clear();
infoWidgets.Clear();
for (int i = 0; i < gamepadComponent.CountActiveGamePads; i++)
{
	UserInterface uiInfo = new UserInterface(Gui.GetCurrent(), uiInfoFile);
	infosUi.Add(uiInfo);
	InfoWidgets info = new InfoWidgets();
	infoWidgets.Add(info);
	InitWidget(nameof(info.infoVBox), out info.infoVBox, uiInfo);
	InitWidget(nameof(info.nameLabel), out info.nameLabel, uiInfo);
	InitWidget(nameof(info.numberLabel), out info.numberLabel, uiInfo);
	InitWidget(nameof(info.playerIndexLabel), out info.playerIndexLabel, uiInfo);
	InitWidget(nameof(info.deviceTypeLabel), out info.deviceTypeLabel, uiInfo);
	InitWidget(nameof(info.modelTypeLabel), out info.modelTypeLabel, uiInfo);
	InitWidget(nameof(info.availableLabel), out info.availableLabel, uiInfo);
	InitWidget(nameof(info.filterSlider), out info.filterSlider, uiInfo);
	InitWidget(nameof(info.lastButtonDownLabel), out info.lastButtonDownLabel, uiInfo);
	InitWidget(nameof(info.lastButtonPressedLabel), out info.lastButtonPressedLabel, uiInfo);
	InitWidget(nameof(info.lastButtonUpLabel), out info.lastButtonUpLabel, uiInfo);
	InitWidget(nameof(info.leftAxesXLabel), out info.leftAxesXLabel, uiInfo);
	InitWidget(nameof(info.leftAxesYLabel), out info.leftAxesYLabel, uiInfo);
	InitWidget(nameof(info.rightAxesXLabel), out info.rightAxesXLabel, uiInfo);
	InitWidget(nameof(info.rightAxesYLabel), out info.rightAxesYLabel, uiInfo);
	InitWidget(nameof(info.leftLastDeltaXLabel), out info.leftLastDeltaXLabel, uiInfo);
	InitWidget(nameof(info.leftLastDeltaYLabel), out info.leftLastDeltaYLabel, uiInfo);
	InitWidget(nameof(info.rightLastDeltaXLabel), out info.rightLastDeltaXLabel, uiInfo);
	InitWidget(nameof(info.rightLastDeltaYLabel), out info.rightLastDeltaYLabel, uiInfo);
	InitWidget(nameof(info.leftTriggerLabel), out info.leftTriggerLabel, uiInfo);
	InitWidget(nameof(info.rightTriggerLabel), out info.rightTriggerLabel, uiInfo);
	InitWidget(nameof(info.lastLeftTriggerDeltaLabel), out info.lastLeftTriggerDeltaLabel, uiInfo);
	InitWidget(nameof(info.lastRightTriggerDeltaLabel), out info.lastRightTriggerDeltaLabel, uiInfo);
	InitWidget(nameof(info.lowFrequencySlider), out info.lowFrequencySlider, uiInfo);
	InitWidget(nameof(info.highFrequencySlider), out info.highFrequencySlider, uiInfo);
	InitWidget(nameof(info.durationSlider), out info.durationSlider, uiInfo);
	InitWidget(nameof(info.vibrationButton), out info.vibrationButton, uiInfo);
	InitWidget(nameof(info.touchpadCanvas), out info.touchpadCanvas, uiInfo);
	gamepadsInfoBox.AddChild(info.infoVBox);
	infoWidgets[i].numberLabel.Text = gamepadComponent.GamepadsInfo[i].number.ToString();
	info.filterSlider.Data = i.ToString();
	info.filterSlider.EventChanged.Connect(ChangeFilter);
	info.vibrationButton.Data = i.ToString();
	info.vibrationButton.EventClicked.Connect(ClickVibrate);
}
```

--------------------------------

### Visualize Applied Horizontal Velocity

Source: https://github.com/wookiee/unigine_docs/blob/main/Csharp_Components.md

Draws a vector indicating the applied horizontal velocity. The vector starts from a point above the shape's center and extends based on the `HorizontalVelocity`. Requires `worldTransform`, `shape`, `HorizontalVelocity`, and `debugColors`.

```UnigineScript
Vec3 p0 = worldTransform.Translate + Vec3.UP * (shape.Radius + shape.Height * 0.5f);
Vec3 p1 = p0 + HorizontalVelocity;
Visualizer.RenderVector(p0, p1, debugColors.appliedHorizontalVelocity);
```

--------------------------------

### Initialize FirstPersonController

Source: https://github.com/wookiee/unigine_docs/blob/main/Csharp_Components.md

Initializes the FirstPersonController by setting up mouse handling, object casting, player transformation, physics bodies, camera, and auxiliary parameters. It configures the player's physics body and shape, sets up the camera's properties, and prepares interaction shapes and movement parameters.

```csharp
private void Init()
{
	mouse_handle = Input.MouseHandle;
	Input.MouseHandle = Input.MOUSE_HANDLE.GRAB;
	// check object type
	Object obj = node as Object;
	if (!obj)
	{
		Log.Error("FirstPersonController: can't cast node to Object\n");
		return;
	}
	// fix player transformation
	// player can only have vertical position, Y axis is used for forward direction
	Vec3 axisY = new Vec3(obj.WorldTransform.AxisY);
	axisY.z = 0;
	axisY = (axisY.Length2 > MathLib.EPSILON ? axisY.Normalized : Vec3.FORWARD);
	obj.WorldTransform = MathLib.SetTo(node.WorldPosition, node.WorldPosition + axisY, vec3.UP, MathLib.AXIS.Y);
	// set dummy body
	if (useObjectBody)
	{
		body = obj.Body as BodyDummy;
		if (!body)
			Log.Warning("FirstPersonController: object doesn't contain BodyDummy, it was created automatically\n");
	}
	if (!body)
	{
		body = new BodyDummy(obj);
		body.Transform = obj.WorldTransform;
	}
	// set capsule shape
	if (useObjectBody)
	{
		if (body.NumShapes > 0)
		{
			for (int i = 0; i < body.NumShapes; i++)
				if (!shape)
					shape = body.GetShape(i) as ShapeCapsule;
			if (!shape)
				Log.Warning("FirstPersonController: body doesn't contain ShapeCapsule, it was created automatically\n");
		}
		else
			Log.Warning("FirstPersonController: body doesn't contain shapes, it was created automatically\n");
	}
	if (!shape)
	{
		shape = new ShapeCapsule(body, capsuleRadius, capsuleHeight);
		body.SetShapeTransform(body.NumShapes - 1, MathLib.Translate(vec3.UP * (capsuleRadius + 0.5f * capsuleHeight)));
		shape.PhysicsIntersectionMask = physicsIntersectionMask;
		shape.CollisionMask = collisionMask;
		shape.ExclusionMask = exclusionMask;
	}

capsuleHeight = shape.Height;
crouchHeight = MathLib.Clamp(crouchHeight, 2.0f * shape.Radius, shape.Height + 2.0f * shape.Radius);
crouchState.currentHeight = shape.Height + 2.0f * shape.Radius;
	// set camera
	if (cameraMode == CameraMode.USE_EXTERNAL && !camera)
		Log.Warning("FirstPersonController: camera is null, it was created automatically\n");
	if (!camera || cameraMode == CameraMode.CREATE_AUTOMATICALLY)
	{
		camera = new PlayerDummy();
		camera.Parent = obj;
		camera.Fov = fov;
		camera.ZNear = nearClipping;
		camera.ZFar = farClipping;
		camera.WorldPosition = obj.WorldTransform * new Vec3(cameraPositionOffset);
		camera.SetWorldDirection(new vec3(axisY), vec3.UP);
		camera.MainPlayer = true;
	}
	if (camera && cameraMode != CameraMode.NONE)
	{
		cameraVerticalAngle = MathLib.Angle(vec3.DOWN, camera.GetWorldDirection());
		cameraVerticalAngle = MathLib.Clamp(cameraVerticalAngle, minVerticalAngle + 90.0f, maxVerticalAngle + 90.0f);
		cameraHorizontalAngle = node.GetWorldRotation().GetAngle(vec3.UP);
		cameraPositionOffset = new vec3(node.IWorldTransform * camera.WorldPosition);
		vec3 cameraDirection = vec3.FORWARD * MathLib.RotateZ(-cameraHorizontalAngle);
		cameraDirection = cameraDirection * MathLib.Rotate(MathLib.Cross(cameraDirection, vec3.UP), 90.0f - cameraVerticalAngle);
		cameraDirection.Normalize();
		camera.SetWorldDirection(cameraDirection, vec3.UP);
	}
	// create cylinder shape for interacting with objects
	if (useObjectsInteraction)
	{
		interactionShape = new ShapeCylinder();
		interactionShape.Enabled = false;
	}
	// set auxiliary parameters
	playerIFps = 1.0f / playerFps;
	crouchTransitionTime = MathLib.Max(crouchTransitionTime, MathLib.EPSILON);
	cosGroundAngle = MathLib.Cos(maxGroundAngle * MathLib.DEG2RAD);
	cosCeilingAngle = MathLib.Cos(maxCeilingAngle * MathLib.DEG2RAD);
	cosStairAngle = MathLib.Cos(maxStairAngle * MathLib.DEG2RAD);
	cosStairsDetectionAngle = MathLib.Cos(stairsDetectionAngle * MathLib.DEG2RAD + MathLib.PI05);
	cosWallStopSlidingAngle = MathLib.Cos(wallStopSlidingAngle * MathLib.DEG2RAD);
#if DEBUG
	maxPassContacts = contactsBufferSize;
#endif
	worldTransform = obj.WorldTransform;
	for (int i = 0; i < Input.NumGamePads; i++)
	{
		Unigine.InputGamePad game_pad = Input.GetGamePad(i);
		if (game_pad.IsAvailable)
		{
			gamePad = game_pad;
			break;
		}
	}
	IsInitialized = true;
}
```

--------------------------------

### Get Current Velocity (C#)

Source: https://github.com/wookiee/unigine_docs/blob/main/Csharp_Components.md

This C# method returns the current velocity based on the selected VelocityGear. It uses a switch expression to map each gear to its corresponding velocity value, defaulting to 0.0f if an unknown gear is selected.

```csharp
float GetVelocity()
{
	return _velocityGear switch
	{
		VelocityGear.GEAR_FIRST => firstGearVelocity,
		VelocityGear.GEAR_SECOND => secondGearVelocity,
		VelocityGear.GEAR_THIRD => thirdGearVelocity,
		_ => 0.0f
	};
}
```

--------------------------------

### Initialize Joystick UI Elements in Unigine

Source: https://github.com/wookiee/unigine_docs/blob/main/Csharp_Components.md

Initializes the main UI layout and populates it with joystick information. It sets up various widgets like HBoxes, VBoxes, and Labels to display joystick status. This function is called once during the setup phase.

```csharp
Gui gui = Gui.GetCurrent();
mainHBox = new WidgetHBox();
backgroundVBox = new WidgetVBox { FontSize = 16, FontOutline = 1, Background = 1, Width = 400 };
backgroundVBox.SetPadding(8, 8, 8, 8);
mainHBox.AddChild(backgroundVBox, Gui.ALIGN_CENTER);
var commonInfoContainer = new WidgetHBox();
backgroundVBox.AddChild(commonInfoContainer);
errorMessageLabel = new WidgetLabel("ACTIVE JOYSTICKS NOT FOUND") { FontSize = 16, FontOutline = 1, Hidden = true };
commonInfoContainer.AddChild(errorMessageLabel);
generalMessageInfo = new WidgetVBox();
commonInfoContainer.AddChild(generalMessageInfo);
countActiveJoysticksLabel = new WidgetLabel() { FontSize = 16, FontOutline = 1 };
countActiveJoysticksContainer = WrapWidget("Active Joysticks:", countActiveJoysticksLabel, generalMessageInfo);
joysticksInfoBox = new WidgetHBox();
joysticksInfoBox.SetSpace(30, 0);
backgroundVBox.AddChild(joysticksInfoBox);
gui.AddChild(mainHBox, Gui.ALIGN_CENTER);
backgroundVBox.BackgroundColor = new vec4(0.0f, 0.0f, 0.0f, 0.5f);
if (joystickComponent == null || joystickComponent.JoysticksCount == 0)
	return;
errorMessageLabel.Hidden = true;
generalMessageInfo.Hidden = false;
countActiveJoysticksLabel.Text = joystickComponent.JoysticksCount.ToString();
infoWidgets = new List<InfoWidgets>();
for (int i = 0; i < joystickComponent.JoysticksCount; i++)
{
	CreateInterface(joystickComponent.JoysticksInfo[i]);
}
```

--------------------------------

### Initialize Joystick UI Elements (C#)

Source: https://github.com/wookiee/unigine_docs/blob/main/Csharp_Components.md

Initializes the main UI elements for joystick management, including setting mouse handling and preparing containers for displaying joystick information and error messages. This method is marked with MethodInit for ordered execution during initialization.

```csharp
/// <summary>
/// Initializes the joystick UI elements and sets up event handlers.
/// </summary>
[MethodInit(Order = 1)]
private void Init()
{
	Input.MouseHandle = Input.MOUSE_HANDLE.USER;
}
```
Tokens:
Raw