csharp_component_samples.sample

<?xml version='1.0' encoding='UTF-8'?>
<meta>
	<samples_pack name="csharp_component_samples">
		<title>C# Component Samples</title>
		<version>2.21.0.1</version>
		<dependency>2.21.0.1</dependency>
		<os>cross</os><workflow>editor2</workflow>
		<precision>double</precision>
		<path>data</path>
		<command>world_load csharp_component_samples</command>
		<custom_app>csharp_component_samples</custom_app>
		<run_workflow>dotnet</run_workflow>
		<bin_type>development</bin_type>
		<api>csdnc</api>
		<plugins>FMOD</plugins>
		<description>
			<![CDATA[
			<p>A set of samples showcasing the use of engine features via C# components for various use cases.</p>
			<p>Programming is easy: application logic is implemented in components, that can be assigned to any nodes in the virtual world to extend their functionality.</p>
			<p>To launch this samples, you should perform the following actions:
				<ul>
					<li>Install one of the following IDEs to work with the source code:
						<ul>
							<li><b><a href="https://code.visualstudio.com/download">Visual Studio Code</a></b>, recommended (C# extension is required)</li>
							<li><b>Visual Studio 2022</b></li>
						</ul>
					</li>
					<li>Download and install <a href="https://dotnet.microsoft.com/en-us/download/dotnet/8.0">.NET Core 8.0</a><br/>If you're using Visual Studio, choose the appropriate .NET Core version:
						<ul>
							<li>
								<a href="https://dotnet.microsoft.com/en-us/download/dotnet/8.0">v8.0.107</a> for Visual Studio 2022
							</li>
						</ul>
					</li>
					<li>Click <b>Copy as Project</b> under this Demo.</li>
					<li>Click <b>Open Editor</b> for the project to run it in the Editor.</li>
					<li>Run the project via the <b>Play</b> button on the Editor's toolbar.</li>
				</ul>
			</p>
			]]>
		</description>
		<features>
			<![CDATA[
				<p>
					<ul>
						<li><b>Animation</b> - blending and lerping animations, applying partial blending of bones, rotating bones via code, controlling animation playback</li>
						<li><b>Arcade Sample</b> - simple but frequently used arcade mechanics: controls, shooting and intersection of bullets with surfaces, node spawning, transformations, and deletion</li>
						<li><b>Cameras</b> - creating and controlling various cameras: first-person-view, orbital, panning, and persecutor camera</li>
						<li><b>CharacterController</b> - first-person character controller implementation</li>
						<li><b>Components</b> - all available types of component parameters</li>
						<li><b>Create Nodes</b> - creating and deleting nodes via code</li>
						<li><b>Input</b> - enabling input from various devices (keyboard, gamepad, joystick, etc.)</li>
						<li><b>Materials</b> - changing material parameters at run time</li>
						<li><b>Navigation</b> - 2D and 3D pathfinding and navigation (navigation meshes, obstacles, sectors)</li>
						<li><b>Sounds</b> - adding and controlling various sounds</li>
						<li><b>Tracker</b> - using Tracker functionality to animate objects (change their position, rotation, and scale) via tracks created in the Tracker tool.</li>
						<li><b>Transformation</b> - object transformations: rotation via Euler angles, local and world transforms</li>
						<li><b>Widgets</b> - using widgets and containers to create a custom GUI</li>
						<li><b>World Intersection</b> - detecting intersections between bounds and nodes, between rays and geometry</li>
					</ul>
				</p>
			]]>
		</features>
		<products>
			<product>tier3_bin_windows</product>
			<product>tier3_bin_channel</product>
			<product>tier3_bin_channel_windows</product>
			<product>tier3_bin_channel_linux</product>
			<product>tier3_src_windows</product>
			<product>tier3_bin_linux</product>
			<product>tier3_src_linux</product>
			<product>tier3_evaluation</product>
			<product>tier2_bin_windows</product>
			<product>tier2_src_windows</product>
			<product>tier2_bin_linux</product>
			<product>tier2_src_linux</product>
			<product>tier2_evaluation</product>
			<product>tier0_bin</product>
			<product>tier0_bin_pro</product>
			<product>tier4_bin</product>
			<product>tier4_evaluation</product>
		</products>
		<images>
			<card_image>.meta/images/csharp_rect.png</card_image>
			<thumb>.meta/images/csharp_sm.png</thumb>
			<image>.meta/images/csharp_001.png</image>
			<image>.meta/images/csharp_002.png</image>
			<image>.meta/images/csharp_003.png</image>
		</images>
	<categories>
		<category id="scene_management" name="Scene Management" order="10" img="data/csharp_component_samples/scene_management/scene_management.png"/>
		<category id="csharp_language_features" name="C# Language Features" order="15" img="data/csharp_component_samples/csharp_language_features/csharp_language_features.png"/>
		<category id="player_controllers" name="Player Controllers" order="20" img="data/csharp_component_samples/player_controllers/player_controllers.png"/>
		<category id="input_handling" name="Input Handling" order="30" img="data/csharp_component_samples/input_handling/input_handling.png"/>
		<category id="app_logic" name="App Logic" order="40" img="data/csharp_component_samples/app_logic/app_logic.png"/>
		<category id="procedural_generation_placement" name="Procedural Generation &amp; Placement" order="50" img="data/csharp_component_samples/procedural_generation_placement/procedural_generation_placement.png"/>
		<category id="multi_threading_performance_optimization" name="Multithreading &amp; Performance Optimization" order="60" img="data/csharp_component_samples/multi_threading_performance_optimization/multi_threading_performance_optimization.png"/>
		<category id="nodes" name="Nodes" order="80" img="data/csharp_component_samples/nodes/nodes.png"/>
		<category id="terrain_modification_usage" name="Terrain Modification &amp; Usage" order="90" img="data/csharp_component_samples/terrain_modification_usage/terrain_modification_usage.png"/>
		<category id="physics" name="Physics" order="100" img="data/csharp_component_samples/physics/physics.png"/>
		<category id="rendering" name="Rendering" order="110" img="data/csharp_component_samples/rendering/rendering.png"/>
		<category id="animation_generic" name="Animation - Generic" order="120" img="data/csharp_component_samples/animation_generic/animation_generic.png"/>
		<category id="animation_characters" name="Animation - Characters" order="125" img="data/csharp_component_samples/animation_characters/animation_characters.png"/>
		<category id="navigation" name="Navigation" order="140" img="data/csharp_component_samples/navigation/navigation.png"/>
		<category id="user_interface" name="User Interface" order="150" img="data/csharp_component_samples/user_interface/user_interface.png"/>
		<category id="sounds" name="Sounds" order="160" img="data/csharp_component_samples/sounds/sounds.png"/>
		<category id="network" name="Network" order="170" img="data/csharp_component_samples/network/network.png"/>
		<category id="unigine_script_interop" name="UnigineScript Interop" order="180" img="data/csharp_component_samples/unigine_script_interop/unigine_script_interop.png"/>
	</categories>
<samples>
<sample title="Additive Animation Blending [Animation Graph]" order="1" id="additive_animation_blending" category_id="animation_characters">
	<sdk_desc>
		<![CDATA[Additive blending of two animations.]]>
	</sdk_desc>
	<desc>
		<brief>
		<![CDATA[Additive blending of two animations.]]>
		</brief>
	</desc>
	<tags>
		<tag>Animation</tag>
	</tags>
</sample>
<sample title="Bones: Partial Blend [Animation Graph]" order="1" id="bones_partial_blend" category_id="animation_characters">
	<sdk_desc><![CDATA[Demonstration of partial blending between two animations using bone-specific interpolation.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[This sample demonstrates partial blending between two animations using bone-specific interpolation.]]>
		</brief>
	</desc>
	<tags>
		<tag>Animation</tag>
	</tags>
</sample>
<sample title="Linear Animation Blending [Animation Graph]" order="1" id="linear_animation_blending" category_id="animation_characters">
	<sdk_desc>
		<![CDATA[Linear interpolation of two animations.]]>
	</sdk_desc>
	<desc>
		<brief>
		<![CDATA[Linear interpolation of two animations.]]>
		</brief>
	</desc>
	<tags>
		<tag>Animation</tag>
	</tags>
</sample>
<sample title="Bones: Rotation [Animation Graph]" order="1" id="bones_rotation" category_id="animation_generic">
	<sdk_desc><![CDATA[Controlling animation playback and directly modifying bone transforms.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[This sample demonstrates how to control animation playback and directly modify bone transforms.]]>
		</brief>
	</desc>
	<tags>
		<tag>Animation</tag>
	</tags>
</sample>
<sample title="Animation Layers Playback" id="animation_layers_playback" category_id="animation_generic">
	<sdk_desc><![CDATA[Using multiple layers in animation playback.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[Animation playback uses animation layers.]]>
		</brief>
	</desc>
	<tags>
		<tag>Animation</tag>
	</tags>
</sample>
<sample title="Curve Animation" id="curve_animation" category_id="animation_generic">
	<sdk_desc><![CDATA[Real-time animation of transforms and materials using <i>Curve2D</i> for flexible, non-linear motion.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to animate both node transforms and material parameters using <i>Curve2D</i>. Separate <i>Curve2d</i> tracks control a node's position, rotation, and scale, evaluated each frame to build the final transformation matrix.</p>
			<p>This setup is useful for creating looping motions and dynamic material effects without relying on external animation assets.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Animation</tag>
		<tag>Basic Recipes</tag>
		<tag>Transformations</tag>
	</tags>
</sample>
<sample title="Material Parameters Animation" id="material_parameters_animation" category_id="animation_generic">
	<sdk_desc><![CDATA[Changing parameters of materials at runtime.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>The <i>Materials</i> sample illustrates how to change the following parameters of materials at runtime:</p>
							<p> - Albedo color</p>
				<p> - Albedo texture</p>
				<p> - Metalness</p>
				<p> - Emission state</p>
				<p> - Cast World Shadow.</p>
					]]>
		</brief>
	</desc>
	<tags>
		<tag>Animation</tag>
		<tag>Materials</tag>
	</tags>
</sample>
<sample title="Track Playback" img="yes" id="track_playback" category_id="animation_generic">
	<sdk_desc><![CDATA[Using tracks to animate objects (position, rotation, and scale).]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to use <i>Tracker</i> to animate objects by changing their position, rotation, and scale through tracks created in the <b>Tracker</b> tool.</p>
			<p>Tracks in code are referred to via names and IDs.</p>
			<p>The <b>TrackPlayback</b> component uses a C# wrapper for <i>Tracker</i> functionality implemented in the <b>Tracker.cs</b> file.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Animation</tag>
	</tags>
</sample>
<sample title="Advanced Event Connection Patterns" id="advanced_event_connection_patterns" category_id="app_logic">
	<sdk_desc><![CDATA[Advanced ways of subscribing to events in UNIGINE: using extra arguments, discarding parameters, and storing connection handles for disconnection.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[This sample demonstrates advanced ways of subscribing to events in UNIGINE: using extra arguments, discarding parameters, and storing connection handles for disconnection.]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[<p>T - rotate around X axis</p><p>Y - rotate around Y axis</p><p>U - rotate around Z axis</p><p>I - rotate around XYZ axes at the same time</p>]]>
	</controls>
	<tags>
		<tag>Systems</tag>
		<tag>Logic</tag>
	</tags>
</sample>
<sample title="Arcade Game Prototype" img="yes" id="arcade_game_prototype" category_id="app_logic">
	<sdk_desc><![CDATA[A simple yet flexible 3D shooter prototype featuring core gameplay systems like shooting, collisions, health management, and dynamic effects.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[<p>This sample showcases a flexible arcade-style interaction system, built with UNIGINE's C# API. It presents foundational gameplay mechanics commonly used in shooter, and action-style applications. The project serves both as a beginner-friendly learning resource and a base for prototyping more advanced features such as basic non-player behavior or scoring logic.</p>
			<b><p>Core Features:</p></b>
							<p> - <b>Player Controller:</b> Control a robot character with keyboard input for movement and rotation.</p>
				<p> - <b>Projectile System:</b> An automated turret fires projectiles using raycasting for hit detection and visual impact effects.</p>
				<p> - <b>Enemy Turret:</b> A rotating turret that periodically shoots projectiles at the player.</p>
				<p> - <b>Health System:</b> The robot takes damage and is destroyed when health reaches zero, with corresponding visual effects and cleanup.</p>
				<p> - <b>Node Spawning &amp; Deletion:</b> Bullets and particle effects are dynamically created and removed, with timed destruction to manage scene performance.</p>
				<p> - <b>Visual FX (Optional):</b> Includes particle effects for shooting, impact, and destruction events.</p>
						<b><p>Use Cases:</p></b>
									<p> - <b>Game Prototyping:</b> Provides a foundation for building shooter mechanics, or arcade-style gameplay.</p>
					<p> - <b>Physics &amp; Interaction:</b> Demonstrates raycasting-based hit detection.</p>
					<p> - <b>Learning Tool:</b> Ideal for beginners exploring the UNIGINE C# API and gameplay scripting.</p>
						]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[<p align=left>Keys <b>UP</b> and <b>DOWN</b> to move forward/backward</p>
		<p align=left>Keys <b>LEFT</b> and <b>RIGHT</b> for clockwise/counterclockwise rotation</p>
		]]>
	</controls>
	<tags>
		<tag>Complex Solutions</tag>
		<tag>Intersections</tag>
		<tag>Physics</tag>
		<tag>Games</tag>
		<tag>Effects</tag>
		<tag>VFX</tag>
		<tag>Decals</tag>
	</tags>
</sample>
<sample title="Component Parameters In Editor" img="yes" id="component_parameters_in_editor" category_id="app_logic">
	<sdk_desc><![CDATA[Demonstration of component parameter types and configuration options.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates possible variations of component parameter types available in the <b>Component System</b>. It includes primitive types, vectors, masks, files, properties, materials, nodes, curves, structs, arrays, and advanced features like conditional visibility and value filtering.</p>
			<p>Select the <b>component_parameters</b> <i>Node Dummy</i> in the Editor and explore all parameter variations in the <i>Parameters</i> window. This serves as a comprehensive reference for available parameter types and their configuration options.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Component System</tag>
		<tag>Programming</tag>
		<tag>Logic</tag>
	</tags>
</sample>
<sample title="Console Interaction" id="console_interaction" category_id="app_logic">
	<sdk_desc><![CDATA[Interacting with the Engine's built-in console and adding custom console commands and variables via API using the <i>Console</i> and <i>ConsoleVariable</i> classes.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to interact with the Engine's built-in console and add custom console commands and variables via API using the <i>Console</i> and <i>ConsoleVariable</i> classes. It shows how to define different types of console variables: <i>ConsoleVariableInt</i>, <i>ConsoleVariableFloat</i>, and <i>ConsoleVariableString</i>, and how to register custom console commands.</p>
			<p>Commands are linked to callback functions using <i>MakeCallback</i>, and can be executed directly from code or entered manually through the console. Commands can also be added and removed dynamically at runtime, making the system flexible for various use cases. Console variables can be accessed or changed through both code and the console interface.</p>
			<p>For demonstration, to move the Material Ball in the scene use the custom command <b>control_node [x] [y] [z]</b> in the Console (`), where <i>x, y, z</i> are the target world coordinates (e.g., <b>control_node 0 5 1</b>).</p>
			<p>This functionality can be used for development, debugging, rapid prototyping, and runtime adjustments in interactive applications.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Systems</tag>
		<tag>Logic</tag>
	</tags>
</sample>
<sample title="Euler Angle Composition And Decomposition" id="euler_angle_composition_and_decomposition" category_id="app_logic">
	<sdk_desc><![CDATA[Showing how the order of angles affects rotation.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>Example of the object rotation using Euler angles. You can also observe different ways of decomposing the current rotation by various angle sequences.</p>
			<p>This example helps to understand 3D rotations using Euler angles. It shows how different sequences can lead to different orientations in space.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Basic Recipes</tag>
		<tag>Transformations</tag>
	</tags>
</sample>
<sample title="Filesystem External Package" id="filesystem_external_package" category_id="app_logic">
	<sdk_desc><![CDATA[Demonstration of working with external package files via the <i>Package</i> class.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to create a custom data package using code and use it to generate objects in the scene.</p>
			<p>It creates a box mesh and spawns it 64 times in the scene with varied positions and rotations.</p>
			<p>Package is a collection of files and data for UNIGINE projects stored in a single file. The <i>Package</i> class is a data provider for the File System. You can use it to load all necessary resources. </p>
			<p>The <i>ExternalPackage</i> class describes the generation of a mesh (in this case, a box) and its saving to a temporary file at a specified path. The class also implements an interface for searching, reading, and retrieving information about files within the package.</p>
			<p>The <i>ExternalPackageSample</i> class adds the created external package, and its contents are used to create meshes with different positions and orientations. This approach allows for quick and convenient management of a large number of objects without adding them by hand.</p>
			<p>Packages can be used to conveniently transfer files between your projects or exchange data with other users, be it content (a single model or a scene with a set of objects driven by logic implemented via C# components) or files (plugins, libraries, execution files, etc.).</p>
			<p>Using this example will help you understand how to organize work with external files, create and manage your own data packages, implement a mechanism for loading and reading data from a package.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Systems</tag>
		<tag>Logic</tag>
		<tag>File System</tag>
	</tags>
</sample>
<sample title="Inverse FPS Usage" id="inverse_fps_usage" category_id="app_logic">
	<sdk_desc><![CDATA[Using <i>Game.IFps</i> to implement movement logic independent of the frame rate.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[This sample demonstrates the importance of using <i>Game.IFps</i> to implement movement logic independent of the frame rate.]]>
		</brief>
	</desc>
	<tags>
		<tag>Logic</tag>
	</tags>
</sample>
<sample title="XML" id="xml" category_id="app_logic">
	<sdk_desc><![CDATA[Creating and manipulating an <i>XML</i> document using the <i>Xml</i> class.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to create and manipulate an <i>XML</i> document using the <i>Xml</i> class. It creates a nested <i>XML</i> tree with multiple child nodes, each containing arguments and optionally a text value.</p>
			<p>The structure is built using the <i>Xml.AddChild()</i> method, and the arguments are parsed using <i>Xml.GetArgName()</i> and <i>Xml.GetArgValue()</i>. After construction, the <i>XML</i> tree is traversed recursively to display the structure and all attributes in the Console output.</p>
			<p>This approach demonstrates the use of the <i>Xml</i> class for working with hierarchical data, which is useful for config files, level data, and other structured content in <i>XML</i> format.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>File Formats</tag>
	</tags>
</sample>
<sample title="Abstract Components" id="abstract_components" category_id="csharp_language_features">
	<sdk_desc><![CDATA[Demonstrating the use of abstract component classes for shared behavior via C# API.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to use abstract classes in the C# Component System to implement common behavior across different components.</p>
			<p>At the core of the sample is the abstract <b>Toggleable</b> component, which defines a shared structure for enabling and disabling functionality. It contains the <b>Toggled</b> property that automatically calls the <i>On()</i> or <i>Off()</i> methods when changed. These methods are abstract and must be implemented in each derived class. The <i>Toggle()</i> method is used to switch the state manually, applying the corresponding behavior and updating the internal state.</p>
			<p>Two specific components, <b>Lamp</b> and <b>Fan</b>, inherit from <b>Toggleable</b> and implement their own versions of the abstract methods. Lamp controls a light source by toggling its emission material state, while Fan continuously rotates the object when active.</p>
			<p>The <b>Toggler</b> component performs interaction by casting a ray from the camera when the left mouse button is pressed. If it hits an object with a <b>Toggleable</b> component attached, it toggles that component's state.</p>
			<p>This setup is useful for scenarios where different types of objects need to respond to a common interaction pattern. Using abstract classes makes it easy to implement consistent logic across objects while still allowing each one of them to behave differently.</p>
		]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
<p><b>Click</b> on the lamp (sphere) and the fan (cube) to toggle them.</p>
		]]>
	</controls>
	<tags>
		<tag>Systems</tag>
		<tag>Component System</tag>
		<tag>Logic</tag>
		<tag>Programming</tag>
	</tags>
</sample>
<sample title="Coroutine Animations" id="coroutine_animations" category_id="csharp_language_features">
	<sdk_desc><![CDATA[Managing (starting, stopping, and coordinating) multiple coroutines in UNIGINE to create non-blocking, time-based animations with UI-driven runtime control.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to implement application logic to be executed across multiple frames using coroutines, their execution can be suspended either by the Engine or manually, and then resumed. Here coroutines are used to create non-blocking, time-based targeted animations on a node. Smooth movement, continuous rotation, and material blinking effects are implemented using coroutine control flow (<b>StartCoroutine, yield return, StopCoroutine</b>). The sample also shows how to manage multiple coroutines simultaneously and stop them selectively.</p>
			<p>You can control coroutine-based animations using a simple GUI which provides a practical way to explore and understand coroutine-driven behavior.</p>
		]]>
		</brief>
	</desc>
	<link_docs>https://developer.unigine.com/docs/code/csharp/coroutines?rlang=cs</link_docs>
	<tags>
		<tag>Systems</tag>
		<tag>Component System</tag>
		<tag>Logic</tag>
		<tag>Programming</tag>
	</tags>
</sample>
<sample title="Input Gamepad" id="input_gamepad" category_id="input_handling">
	<sdk_desc>
		<![CDATA[This sample demonstrates how to add input from the gamepad to the project.]]>
	</sdk_desc>
	<desc>
		<brief>
		<![CDATA[This sample demonstrates how to add input from the gamepad to the project.]]>
		</brief>
	</desc>
	<tags>
		<tag>Input &amp; Controls</tag>
	</tags>
</sample>
<sample title="Input Joystick" id="input_joystick" category_id="input_handling">
	<sdk_desc><![CDATA[This sample demonstrates how to add advanced joystick input handling, supporting multiple controllers with real-time axis/button monitoring and force feedback effects in UNIGINE.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to add advanced joystick input handling to a project using the <i>InputJoystick.cs</i> component assigned to <b>NodeDummy</b>, supporting multiple controllers with real-time axis/button monitoring and force feedback effects in UNIGINE.</p>
			<p>It features a <b>dynamic UI for testing 10+ force feedback types</b> (springs, vibrations, waves) and automatically handles device connection/disconnection events.</p>
			<p><b>Use Cases:</b></p>
			<p>Ideal for racing/flight simulators or any project requiring precise controller input with haptic feedback.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Input &amp; Controls</tag>
	</tags>
</sample>
<sample title="Input Keyboard And Mouse" id="input_keyboard_mouse" category_id="input_handling">
	<sdk_desc><![CDATA[This sample demonstrates how to add monitoring of keyboard and mouse input, tracking key states, mouse movements, wheel events, cursor positions, and real-time input data.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to add monitoring of keyboard and mouse input, tracking key states, mouse movements, wheel events, and cursor positions across different coordinate systems using the <i>InputKeyboardAndMouse.cs</i> component assigned to <b>NodeDummy</b>. It displays real-time input data including key presses, mouse deltas, and text input.</p>
			<p>The sample shows three mouse handling modes:</p>
							<p> - <b>GRAB</b> - locks and hides the cursor</p>
				<p> - <b>SOFT</b> - locks the cursor to the window but keeps it visible</p>
				<p> - <b>USER</b> - leaves mouse behavior completely under user control.</p>
					]]>
		</brief>
	</desc>
	<tags>
		<tag>Input &amp; Controls</tag>
	</tags>
</sample>
<sample title="Touch" id="touch" category_id="input_handling">
	<sdk_desc><![CDATA[This sample demonstrates how to add multi-touch input from the touchscreen, visualizing finger positions with dynamic circles and displaying real-time coordinates to the project.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[This sample demonstrates how to add multi-touch input from the <i><b>touchscreen</b></i>, visualizing finger positions with dynamic circles and displaying real-time coordinates to the project using the <i>InputTouches.cs</i> component assigned to <b>NodeDummy</b>.]]>
		</brief>
	</desc>
	<tags>
		<tag>Input &amp; Controls</tag>
	</tags>
</sample>
<sample title="Asynchronous Meshes And Textures Loading" id="asynchronous_meshes_and_textures_loading" category_id="multi_threading_performance_optimization">
	<sdk_desc><![CDATA[Loading meshes and textures in a separate thread using the <i>AsyncQueue</i> class.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample shows how to load resources like meshes and textures in the background using the <i>AsyncQueue</i> class. Files are loaded in a separate thread, so the main application stays responsive.</p>
			<p>Meshes and textures are added to the loading queue, and the system listens for events to know when each resource is ready. When a mesh finishes loading, it's removed from the queue. For textures, an event handler is used to handle their completion. The sample also demonstrates how to group and manage resource requests, making it easier to control the loading process.</p>
			<p>This kind of async loading is useful for streaming large levels, loading assets on demand in VR, or preloading data in simulations without freezing the interface.</p>
		]]>
		</brief>
	</desc>
	<link_docs>https://developer.unigine.com/docs/api/library/filesystem/class.asyncqueue?rlang=cs</link_docs>
	<tags>
		<tag>Systems</tag>
		<tag>Optimization</tag>
		<tag>File System</tag>
		<tag>Multithreading</tag>
	</tags>
</sample>
<sample title="Asynchronous Nodes Loading Stress-Test" id="asynchronous_nodes_loading_stress_test" category_id="multi_threading_performance_optimization">
	<sdk_desc><![CDATA[Asynchronous node loading via <i>AsyncQueue</i> with main-thread spatial integration.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to asynchronously load large number of nodes using the <i>AsyncQueue</i> class while ensuring correct activation on the main thread.</p>
			<p>In UNIGINE, world nodes must be created only from the main thread. To comply with this restriction and avoid blocking the main thread, the sample performs the initial node loading in a background thread, and then schedules a follow-up task on the main thread to finalize activation by calling <i>updateEnabled()</i> - a method that registers the node and its children in the world's spatial structure.</p>
			<p>With the built-in Profiler enabled, you can observe how the engine handles increasing load smoothly and avoids frame spikes.</p>
		]]>
		</brief>
	</desc>
	<link_docs>https://developer.unigine.com/docs/api/library/filesystem/class.asyncqueue?rlang=cs</link_docs>
	<tags>
		<tag>Systems</tag>
		<tag>Optimization</tag>
		<tag>Multithreading</tag>
		<tag>World Management</tag>
	</tags>
</sample>
<sample title="Asynchronous Tasks Scheduler Configuration" id="asynchronous_tasks_scheduler_configuration" category_id="multi_threading_performance_optimization">
	<sdk_desc><![CDATA[Managing tasks via <i>AsyncQueue</i> class with dirrefent thread types, parallel execution and frame control.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstates how to schedule and run different types of tasks using the <i>AsyncQueue class</i>. It shows how to execute operations in different thread types, control thread count, and choose whether tasks should complete within the current frame or run freely in the background.</p>
							<p> - <b>Async</b> - non-blocking execution in a single thread. Useful for offloading tasks without stalling the main thread.</p>
				<p> - <b>Async Multithread</b> - parallel execution across multiple threads. Each thread receives its own portion of work. Does not block the caller.</p>
				<p> - <b>Frame-Async Multithread</b> - same as <b>Async Multithread</b>, but ensures all threads complete their tasks within the current frame.</p>
				<p> - <b>Sync Multithread</b> - multi-threaded execution that blocks the calling thread until all threads finish.</p>
				<p> - <b>Frame-Sync Multithread</b> - same as <b>Sync Multithread</b>, but ensures all threads complete their tasks within the current frame.</p>
					]]>
		</brief>
	</desc>
	<link_docs>https://developer.unigine.com/docs/api/library/filesystem/class.asyncqueue?rlang=cs</link_docs>
	<tags>
		<tag>Systems</tag>
		<tag>Optimization</tag>
		<tag>Multithreading</tag>
	</tags>
</sample>
<sample title="Microprofiler Custom Counters" id="microprofiler_custom_counters" category_id="multi_threading_performance_optimization">
	<sdk_desc><![CDATA[Using <i>Microprofile</i>, an advanced CPU/GPU profiler, to track performance and estimate the time spent on different sections of code.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[This sample demonstrates methods for tracking performance and estimating the time spent on different sections of code. For this purpose, it uses <b>Microprofile</b>, an advanced CPU/GPU profiler with per-frame inspection support.]]>
		</brief>
	</desc>
	<exec>microprofile_enabled 1</exec>
	<edit>microprofile_enabled 1</edit>
	<tags>
		<tag>Systems</tag>
		<tag>Optimization</tag>
	</tags>
</sample>
<sample title="Navigation Mesh 2D" id="navigation_mesh_2d" category_id="navigation">
	<sdk_desc><![CDATA[Calculating and visualizing 2D navigation paths using a <i>Navigation Mesh</i> object and <i>PathRoute</i> class.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to calculate and visualize 2D navigation paths using the <b>Navigation Mesh</b> object and <i>PathRoute</i> class via the C# API. It shows how to build a route between two points on a navigation mesh and renders the result for debugging or visualization purposes.</p>
			<p>This setup is useful for prototyping AI navigation, testing route validity, and analyzing the structure of navigable areas in 2D gameplay scenarios.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Navigation &amp; Pathfinding</tag>
		<tag>Visualizer (Visual Debug)</tag>
	</tags>
</sample>
<sample title="Navigation Mesh 2D Demo" id="navigation_mesh_2d_demo" category_id="navigation">
	<sdk_desc><![CDATA[Calculating and visualizing 2D navigation paths with moving targets using <i>Navigation Mesh</i> object and <i>PathRoute</i> class.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to implement dynamic 2D pathfinding using a <b>Navigation Mesh</b> object, with autonomous robots navigating toward randomly positioned targets. Each robot uses a <i>PathRoute</i> class instance to calculate a valid route within the navigation mesh and moves along it in real time.</p>
			<p>This setup is useful for prototyping simple AI behavior such as patrolling or target chasing, where agents continuously search for and move toward dynamic goals.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Navigation &amp; Pathfinding</tag>
		<tag>Visualizer (Visual Debug)</tag>
	</tags>
</sample>
<sample title="Navigation Obstacles 2D" id="navigation_obstacles_2d" category_id="navigation">
	<sdk_desc><![CDATA[Demonstrating the use of <i>Obstacles</i> within a <i>Navigation Mesh</i> to dynamically modify valid pathfinding areas at runtime.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to use dynamic <b>Obstacles</b> in combination with a <b>Navigation Mesh</b> to influence 2D pathfinding in runtime. When an obstacle overlaps the navigation mesh, it temporarily modifies the traversable area, forcing the pathfinding algorithm to recalculate a valid route around it.</p>
			<p>This example is useful for prototyping interactive environments, where navigation must adapt to moving objects, barriers, or other gameplay elements affecting traversal.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Navigation &amp; Pathfinding</tag>
		<tag>Visualizer (Visual Debug)</tag>
	</tags>
</sample>
<sample title="Navigation Sectors 2D" id="navigation_sectors_2d" category_id="navigation">
	<sdk_desc><![CDATA[Calculating and visualizing 2D navigation paths using <i>Navigation Sector</i> objects and the <i>PathRoute</i> class.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to calculate and visualize 2D navigation paths using the <b>Navigation Sector</b> objects and <i>PathRoute</i> class. Unlike navigation meshes, sectors allow defining modular navigable areas that can be enabled, disabled, or moved dynamically at runtime.</p>
			<p>This 2D version is well-suited for top-down navigation, grid-based layouts, or layered 2D gameplay. For more complex 3D navigation scenarios, see the <i>navigation_sectors_3d</i> sample.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Navigation &amp; Pathfinding</tag>
		<tag>Visualizer (Visual Debug)</tag>
	</tags>
</sample>
<sample title="Navigation Sectors 3D" id="navigation_sectors_3d" category_id="navigation">
	<sdk_desc><![CDATA[Calculating and visualizing 3D navigation paths using <i>Navigation Sector</i> objects and the <i>PathRoute</i> class.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to calculate and visualize 3D navigation paths using the <b>Navigation Sector</b> objects and <i>PathRoute</i> class via the C# API. Unlike navigation meshes, sectors allow defining modular navigable areas that can be enabled, disabled, or moved dynamically at runtime.</p>
			<p>This setup is useful for multilevel structures or modular environments where the layout changes dynamically. For simpler 2D navigation scenarios, see the <i>navigation_sectors_2d</i> sample.</p> 		]]>
		</brief>
	</desc>
	<tags>
		<tag>Navigation &amp; Pathfinding</tag>
		<tag>Visualizer (Visual Debug)</tag>
	</tags>
</sample>
<sample title="Navigation Sectors 3D Demo" id="navigation_sectors_3d_demo" category_id="navigation">
	<sdk_desc><![CDATA[Calculating and visualizing 3D navigation paths using <i>Navigation Sector</i> and the <i>PathRoute</i> class to track dynamic targets.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to implement 3D pathfinding logic using <b>Navigation Sector</b> and <i>PathRoute</i> class via the C# API. Robots autonomously fly and collect coins, which are dynamically placed at random locations within the navigation sector volume.</p>
			<p>The main logic is implemented in the <b>PathRoute3DWithTarget</b> component. A <i>PathRoute</i> object is created to calculate a valid 3D path from the robot's current position to the target using <i>PathRoute.Create3D()</i>. Once a valid path is generated, the robot rotates toward the next point in the path and moves forward. If the path becomes invalid - for example, if the target ends up in an unreachable area, then the system selects a new target location and recalculates the route.</p>
			<p>Target positions are chosen at random inside the volume of a <i>Navigation Sector</i>, using <i>Inside3D()</i> for validation. The route is automatically updated as the robot approaches the target. If the route is successfully resolved, the path is drawn on screen using <i>RenderVisualizer()</i>.</p>
			<p>To help visualize active navigation areas, the <b>NavigationSectorVisualizer</b> component renders the geometry of all sectors during runtime.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Navigation &amp; Pathfinding</tag>
		<tag>Visualizer (Visual Debug)</tag>
	</tags>
</sample>
<sample title="HTTP Image Request" id="http_image_request" category_id="network">
	<sdk_desc><![CDATA[This sample shows how to implement an asynchronous <i>HTTP</i> request to a <i>REST API</i> to download image files and apply them to scene objects at runtime.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample shows how to implement an asynchronous <i>HTTP</i> request to a <i>REST API</i> to download image files and apply them to scene objects at runtime.</p>
			<p>Two requests are performed to retrieve sample image data:</p>
							<p> - <b>eu.httpbin.org/image/png</b> - to download a <i>PNG</i> image</p>
				<p> - <b>eu.httpbin.org/image/jpeg</b> - to download a <i>JPEG</i> image</p>
						<p>Only <i>PNG</i> and <i>JPEG</i> formats are supported for runtime loading into an <i>Image</i> Class instance from raw data.</p>
			<p>Once an image is retrieved, it is loaded from raw byte data using the <i>Image.Load()</i> method. If successful, the image is assigned to the albedo texture slot of the target material using <i>Material.SetTextureImage()</i>. The texture is applied at runtime to the specified surface of an object in the scene. If loading fails, the downloaded data is written to a file for further inspection.</p>
			<p>This sample showcases a practical approach to fetching external media assets, validating them, and using them in your scenes or application logic.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Network</tag>
	</tags>
</sample>
<sample title="HTTP Request Handling" img="yes" id="http_request_handling" category_id="network">
	<sdk_desc><![CDATA[Implementing asynchronous <i>HTTP GET</i> requests to external <i>REST API</i> and displaying the retrieved data in the user interface.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to implement asynchronous <i>HTTP GET</i> requests to external <i>REST API</i> and display the retrieved data in the user interface.</p>
			<p>For demonstration, the sample performs two consecutive requests to external weather <i>API</i> and displays the results in real time.</p>
							<p> - <b>Geocoding</b> - resolving a location by name using <i>geocoding-api.open-meteo.com</i>.</p>
				<p> - <b>Current weather conditions</b> - retrieving live meteorological data for the selected location using <i>api.open-meteo.com</i>.</p>
						<p>The <i>JSON</i> response is processed using the <i>Json</i> Class and displayed in the sample <i>UI</i>. Additional response details can be viewed in the console output.</p>
			<p>You can interactively test the workflow by entering a city name in the <i>UI</i>, viewing a list of possible matches, and selecting a specific location. This triggers a request for up-to-date weather data, which is then parsed and displayed in the <i>UI</i>.</p>
			<p>Asynchronous processing ensures that network operations do not block or degrade the simulation performance.</p>
			<p>This sample can serve as a foundation for integrating any external data providers.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Network</tag>
	</tags>
</sample>
<sample title="TCP Sockets" id="tcp_sockets" category_id="network">
	<sdk_desc><![CDATA[Establishing and managing <i>TCP</i> socket connections between a server and multiple clients each represented by a UNIGINE-application. Clients can connect to the server, exchange text messages via the Console, and receive camera transform updates from the server.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to establish and manage <i>TCP</i> socket connections between a server and multiple clients each represented by a UNIGINE-application. Clients can connect to the server, exchange text messages via the Console (<b>send_msg</b> command), and receive camera transform updates from the server.</p>
			<p><b>You need to have two instances of this 'C# Samples' app running for this sample to work.</b></p>
			<p>Each instance can operate in one of two modes: <i>Server</i> or <i>Client</i>. To select the mode click on the corresponding button below. There you can also specify the desired <i>host and port</i>.</p>
			<p>The server uses a non-blocking socket to accept client connections and creates a dedicated background thread for each connection. The communication protocol is based on custom messages (e.g., text or camera transforms) packed and unpacked using <i>Blob</i> streams. On the client side, a socket is created and connected to the server. Incoming and outgoing messages are sent/received using two threadsafe queues. To send text messages to the peer use the sample-specific console command <b>send_msg</b> (e.g. <b>send_msg hello world</b>)</p>
			<p>Incoming messages are parsed using message headers. Both client and server use message buffering, timeouts, and validation checks to maintain connection stability and prevent invalid data processing.</p>
			<p>The sample provides options to configure the server address and port, switch between modes, and monitor active connections.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Network</tag>
		<tag>Basic Recipes</tag>
	</tags>
</sample>
<sample title="UDP Sockets" id="udp_sockets" category_id="network">
	<sdk_desc><![CDATA[Using the sockets API to send and receive UDP messages in the network between two peers each represented by a UNIGINE-application.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample shows how to use the sockets API to send and receive UDP messages between two peers in the network.</p>
			<p><b>You need to have two instances of this 'C# Samples' app running for this sample to work.</b></p>
			<p>Each instance can operate in one of two modes: <i>Sender</i> or <i>Receiver</i>. To select the mode click on the corresponding button below. There you can also specify the <i>Receiver's hostname and port</i>.</p>
			<p>In <i>Sender</i> mode the app packs the player's camera transform into a datagram and sends it to the <i>Receiver</i> on every engine update.</p>
			<p>While in this mode you can also send text messages to the peer by using this sample-specific console command <b>send_msg</b> (e.g., <b>send_msg hello world</b>).</p>
			<p>In <i>Receiver</i> mode the app receives and interprets incoming messages from the peer: the text messages are written to console, and the camera transforms are applied to the player.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Network</tag>
		<tag>Basic Recipes</tag>
	</tags>
</sample>
<sample title="Cluster" id="cluster" category_id="nodes">
	<sdk_desc><![CDATA[Dynamic manipulation of <i>ObjectMeshCluster</i> in UNIGINE, showcasing how to add/remove mesh instances at runtime through user interaction.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates dynamic manipulation of <b>ObjectMeshCluster</b> in UNIGINE, showcasing how to add/remove mesh instances at runtime through user interaction. A <b>Mesh Cluster</b> allows you to bake identical meshes (with the same material applied to their surfaces) into a single object, which provides less cluttered spatial tree, reduces the number of texture fetches and speeds up rendering.</p>
			<p><b>Core Features:</b></p>
							<p> - <b>Placement and Removal</b> - click on empty ground adds a new mesh at the clicked position, click on existing cluster geometry removes the selected mesh instance from the cluster</p>
				<p> - <b>Raycasting and Intersection Testing</b> - casts a ray from the camera through the mouse position to detect whether the user clicked on a cluster mesh or terrain</p>
						<p><b>Use Cases:</b></p>
							<p> - Scattering objects like rocks, grass, or debris</p>
				<p> - Dynamic level editing and environment design</p>
				<p> - Performance-sensitive applications with many similar mesh instances.</p>
					]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
		<b>Сlick</b> on an existing mesh removes it from the cluster.<br/><b>Сlick</b> in an empty space adds a new mesh.
		]]>
	</controls>
	<tags>
		<tag>Optimization</tag>
		<tag>Objects</tag>
		<tag>World Management</tag>
	</tags>
</sample>
<sample title="Water Surface Parameters Fetch" id="water_surface_parameters_fetch" category_id="nodes">
	<sdk_desc><![CDATA[This sample demonstrates how various parameters influence the accuracy of fetch and intersection operations on the Global Water object across different Beaufort levels.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how various parameters influence the accuracy of <b>fetch</b> (sampling water height and normal) and <b>intersection</b> (ray-water collision detection) operations on the <b>Global Water</b> object across different <b>Beaufort</b> levels (the Beaufort slider).</p>
			<p>You can interactively adjust the following parameters:</p>
							<p> - <b>Steepness Quality</b>: Controls wave detail resolution used in sampling.</p>
				<p> - <b>Amplitude Threshold</b>: Filters out minor waves to improve performance at the cost of detail.</p>
				<p> - <b>Precision</b>: Controls ray-water intersection accuracy. Lower values reduce jitter when intersecting at an angle.</p>
				<p> - <b>Intersection Angle</b>: Adjusts the incoming ray direction for intersection tests, helping evaluate how steep angles affect detection stability.</p>
						<p>The UI also allows you to:</p>
							<p> - Select between <b>Fetch</b> and <b>Intersection</b> modes</p>
				<p> - Show or hide <b>normals</b> at the sampled points</p>
				<p> - Adjust the <b>number of samples</b> and <b>visual point size</b></p>
						<p>Intersection rays are visualized with blue arrows. If jitter occurs at non-zero intersection angles, try lowering the <b>Precision</b> value.</p>
			<p>This sample is useful for fine-tuning water interaction accuracy in physics, gameplay, and visual effects - especially when working with sloped or moving viewpoints (e.g., cameras, characters, or objects interacting with water).</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Water</tag>
		<tag>Maritime</tag>
		<tag>Intersections</tag>
	</tags>
</sample>
<sample title="Body Events" id="body_events" category_id="physics">
	<sdk_desc><![CDATA[Demonstrating the usage of <i>Frozen, Position</i>, and <i>ContactEnter</i> events of the <i>Body</i> class via C# API.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to use the <i>Frozen</i>, <i>Position</i>, and <i>ContactEnter</i> events of the <i>Body</i> class via the C# API. These events allow responding to physical state changes, such as when a rigid body comes to rest, moves, or collides with another object or surface.</p>
			<p>The sample builds a pyramid of boxes by cloning a mesh and arranging it in several layers. Physics settings are adjusted to improve the stability of the stacked boxes and ensure accurate detection of movement or rest states.</p>
			<p>This approach is useful for debugging physical behaviors, providing visual feedback in simulations, or triggering logic based on changing body states.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Physics</tag>
		<tag>Systems</tag>
		<tag>Visualizer (Visual Debug)</tag>
	</tags>
</sample>
<sample title="Body Fracture Explosion" id="body_fracture_explosion" category_id="physics">
	<sdk_desc><![CDATA[Simulating a radial explosion that triggers <i>BodyFracture</i> object to crack and applies forces to its pieces.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[		<p>This sample demonstrates how to simulate an explosion that fractures physical objects within its radius using the <i>BodyFracture</i> class. Each object affected by the explosion is dynamically fractured into separate physical fragments depending on its proximity to the center of the explosion and the decreasing explosion strength over distance.</p>
		<p>The force applied to the fragments pushes them outward from the explosion center, creating a realistic dispersal effect. A built-in debug visualization clearly displays the explosion radius and the direction of the applied forces, making it easier to understand and adjust the fracture behavior and explosion dynamics.</p>
		<p>Press <i>Explode!</i> to manually trigger the explosion.</p>
		<p>This example is ideal for scenarios that require realistic destruction, dynamic fracture effects, or visual representations of physical object damage.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Physics</tag>
		<tag>Systems</tag>
		<tag>Logic</tag>
	</tags>
</sample>
<sample title="Body Fracture Falling Spheres" id="body_fracture_falling_spheres" category_id="physics">
	<sdk_desc><![CDATA[Continuously fracturing falling objects upon collision using the <i>BodyFracture</i> class.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates continuous fracturing of objects using <i>BodyFracture</i> class.</p>
			<p>Spheres are periodically spawned every 3 seconds and fall freely under gravity. Upon collision with the ground, each sphere fractures dynamically into multiple physical fragments.</p>
			<p>The sample includes a debug visualization that displays mesh wireframes, providing clear insight into internal mesh structure and fracture patterns generated upon impact.</p>
			<p>This example can be used to explore and evaluate destruction mechanics, test mesh-based fracturing setups, and visually analyze breakage behavior in real-time scenarios.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Physics</tag>
		<tag>Systems</tag>
		<tag>Logic</tag>
	</tags>
</sample>
<sample title="Body Fracture Shooting Gallery" id="body_fracture_shooting_gallery" category_id="physics">
	<sdk_desc><![CDATA[Implementation of a basic physics-driven shooting gallery using <i>Fracture Body</i>.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample shows how to simulate projectile-based interactions in a simple shooting gallery setup using <b>Fracture Body</b>. When the left mouse button is clicked, a projectile is spawned in front of the camera and propelled forward. Target objects in the scene react to the impact physically and can be fractured using the <b>Fracture Body</b> system to simulate realistic destruction effects.</p>
			<p><b>Use Cases:</b></p>
									<p> - Prototyping physics-based shooting mechanics.</p>
					<p> - Demonstrating <b>Fracture Body</b> impulse interactions.</p>
					<p> - Testing fracture behaviors in destructible environment setups.</p>
						]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[<p><b>LMB</b> - fire a projectile.</p>]]>
	</controls>
	<tags>
		<tag>Basic Recipes</tag>
		<tag>Physics</tag>
	</tags>
</sample>
<sample title="Joint Events" id="joint_events" category_id="physics">
	<sdk_desc><![CDATA[Demonstrating the usage of the <i>Broken</i> event of the <i>Joint</i> class via C# API.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to use the <i>Broken</i> event of the <i>Joint</i> class via the C# API. This event allows you to react when a joint is broken due to physical forces during the simulation.</p>
			<p>A simple bridge structure is created by cloning a mesh and connecting multiple sections using hinge joints. Some sections are dynamic (<i>BodyRigid</i>) and others are static (<i>BodyDummy</i>) to anchor the ends. Additionally, a few weights are dropped onto the bridge to cause joint breakage. The scene is configured to showcase physically reactive behavior through joints under load. When a joint breaks, the lambda is triggered, changing the material of the connected objects to visually indicate the break.</p>
			<p>You can use this for detecting breakage in joint-based systems or adding visual feedback to destruction mechanics.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Physics</tag>
		<tag>Systems</tag>
		<tag>Visualizer (Visual Debug)</tag>
	</tags>
</sample>
<sample title="Physics Movement" id="physics_movement" category_id="physics">
	<sdk_desc><![CDATA[Simple logic of moving an object using physical methods (by force or by impulse).]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates a simple logic of moving an object using physical methods (by force or by impulse).</p>
			<p>You can choose the desired method and control maximum speed, rotation speed, and accelerations using sliders.</p>
		]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
		<p align=left><b>W/S</b> - Move forward/backward.<br/>
		<b>A/D</b> - Turn left/right.<br/>
		<b>SPACE</b> - Jump.<br/>
		<b>SHIFT</b> - Brake.</p>
		]]>
	</controls>
	<tags>
		<tag>Physics</tag>
	</tags>
</sample>
<sample title="Update Physics" id="update_physics" category_id="physics">
	<sdk_desc><![CDATA[Demonstration of the difference between iplementation of physics-driven movement within the <i>update()</i> and <i>updatePhysics()</i> methods.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates the difference between <i>update()</i> and <i>updatePhysics()</i> methods.</p>
			<p>The sample features two physics-enabled cubes that move back and forth along the X-axis. The movement logic is implemented via in the <i>UpdatePhysicsUsageController.cs</i> file.</p>
			<p>Use <i>updatePhysics()</i> to implement continuous or physics-dependent operations (e.g., force application, collision response), as it runs at a fixed time step, unlike <i>update()</i> which depends on the rendering frame rate.</p>
			<p>Use the <b>Max FPS</b> slider to change the target frame rate.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Physics</tag>
		<tag>Logic</tag>
	</tags>
</sample>
<sample title="CAD-Style Camera Panning" id="cad_style_camera_panning" category_id="player_controllers">
	<sdk_desc><![CDATA[A camera moving parallel to the screen plane.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[This sample demonstrates a camera moving parallel to the screen plane using the <i>CameraPanning.cs</i> component assigned to a <i>PlayerDummy</i> node.]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
			<p><b>RMB (Drag)</b> - Rotate the camera</p>
			<p><b>LMB (Drag)</b> - Pan the camera</p>  
			<p><b>Mouse Wheel</b> - Zoom in and out</p>  
		]]>
	</controls>
	<tags>
		<tag>Cameras</tag>
		<tag>Input &amp; Controls</tag>
	</tags>
</sample>
<sample title="Camera First Person" id="camera_first_person" category_id="player_controllers">
	<sdk_desc><![CDATA[A first-person spectator-style camera with free movement.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[This sample demonstrates a first-person spectator-style camera with free movement.]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
			<p><b>W</b> - Move forward</p>
			<p><b>S</b> - Move backward</p>
			<p><b>A</b> - Move left</p>
			<p><b>D</b> - Move right</p>
			<p><b>Left Shift</b> - Increase movement speed</p>
			<p><b>Mouse Movement</b> - Rotate the camera</p>
		]]>
	</controls>
	<tags>
		<tag>Cameras</tag>
		<tag>Input &amp; Controls</tag>
	</tags>
</sample>
<sample title="Camera Zoom" id="camera_zoom" category_id="player_controllers">
	<sdk_desc><![CDATA[Creating interactive camera system with adjustable zoom and focus on selectable scene targets.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates a zoom and camera focus system that allows the user to inspect predefined targets in the scene and adjust the zoom level. Three info boards are placed throughout the scene, each with an in-world GUI panel showing its distance from the player and its dimensions. These panels update automatically in real time based on the player's position.</p>
			<p>The user can select any target using dedicated UI buttons, prompting the camera to focus on the selected object.</p>
			<p>Zoom is controlled via a slider that adjusts the camera's field of view. As the FOV changes, related parameters such as mouse sensitivity and render distance scaling are adjusted as well to maintain a consistent experience. A reset button restores all values to default.</p>
			<p>This setup is useful for scenarios that require object-focused viewing, such as inspection tools, scene walkthroughs, or any case where adjustable zoom and camera focus help users better understand or explore the scene.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Cameras</tag>
		<tag>Transformations</tag>
		<tag>Basic Recipes</tag>
	</tags>
</sample>
<sample title="First-Person Controller" id="first_person_controller" category_id="player_controllers">
	<sdk_desc><![CDATA[Implementation of a first-person character controller with an advanced movement system and collision detection.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates a first-person character controller implemented as a component attached to a <i>PlayerDummy</i>.</p>
			<p>The controller uses Shape-Surface collisions to detect ground, walls, and slopes, and applies slope-aware movement to ensure stable walking on inclined geometry. It supports walking, running, jumping, air movement, smooth crouching, and camera rotation with vertical limits. Auto-stepping allows the character to traverse small obstacles, and Shape-Shape collisions are used to interact with physical objects by applying impulses.</p>
		]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
		<p><b>W/A/S/D</b> - control camera movement</p>
		<p><b>Shift</b> - accelerate</p>
		<p><b>Space</b> - jump</p>
		<p><b>Ctrl</b> - crouch</p>
		<p><b>Mouse movement</b> - look around</p>
		]]>
	</controls>
	<tags>
		<tag>Cameras</tag>
		<tag>Basic Recipes</tag>
		<tag>Intersections</tag>
		<tag>Physics</tag>
	</tags>
</sample>
<sample title="Observer Controller" id="observer_controller" category_id="player_controllers">
	<sdk_desc><![CDATA[Implementation of a free-flying camera similar to the one used in the UnigineEditor (with zooming, panning, focusing and speed control).]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample replicates the free camera used in the UnigineEditor. The camera offers the following key features:</p>
									<p> - <b>Fly-Through Mode</b> Freely move the camera in all directions using keyboard and mouse controls.</p>
					<p> - <b>Focus on Objects</b> Center the camera on any selected object and adjust distance automatically.</p>
					<p> - <b>Zoom &amp; Pan</b> Zoom in and out, and pan while preserving view direction.</p>
					<p> - <b>Speed Control Menu</b> Switch between predefined movement speeds (<b>1-3</b>) or adjust custom speed values.</p>
					<p> - <b>Position Management</b> Set or teleport the camera to specific world coordinates through the menu.</p>
						]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
		<p> - <b>F3</b>: show/hide the camera control menu</p>
		<p> - <b>RMB (hold)</b>: switch to Spectator mode</p>
		<p> - <b>RMB + mouse</b>: look around</p>
		<p> - <b>RMB + W/A/S/D, Q/E</b>: camera movement</p>
		<p> - <b>Alt + RMB</b>: switch to zooming mode</p>
		<p> - <b>Alt + MMB</b>: switch to panoramic movement mode</p>
		<p> - <b>F</b>: focus on the object under the mouse cursor</p>
		<p> - <b>1, 2, 3</b>: switch movement speed<br/><br/></p>
		<p>You can customize the key bindings in the camera properties within the Editor.</p>
		]]>
	</controls>
	<tags>
		<tag>Complex Solutions</tag>
		<tag>Cameras</tag>
	</tags>
</sample>
<sample title="Orbit Camera Controller" id="orbit_camera_controller" category_id="player_controllers">
	<sdk_desc><![CDATA[Demonstration of an orbital camera rotating around a target.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates an orbital camera rotating around a target.</p>
			<p>The <i>CameraOrbit.cs</i> component enables orbit-style camera movement around a target object using a <i>PlayerDummy</i> node. Input is handled via the <i>CameraControls.cs</i> component, which provides configurable input controls for camera movement and zoom.</p>
		<p>The camera behavior can be customized using the exposed parameters: <i>Angular Speed, Zoom Speed, Min/Max Distance</i>, and <i>Min/Max Vertical Angle</i>. The <i>Target</i> field defines the object the camera orbits around.</p>
		]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
				<p><b>Mouse Movement</b> - Rotate the camera</p>
				<p><b>Mouse Wheel</b> - Zoom in and out</p>
			]]>
	</controls>
	<tags>
		<tag>Cameras</tag>
		<tag>Input &amp; Controls</tag>
	</tags>
</sample>
<sample title="Persecutor Controller" id="persecutor_controller" category_id="player_controllers">
	<sdk_desc><![CDATA[A third-person camera following a moving target.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates a camera following a moving target.</p>
			<p>The <i>CameraPersecutor.cs</i> component implements a third-person follow camera that smoothly tracks a moving target defined in the <i>Target</i> field. The camera adjusts its distance, pitch, and yaw to maintain the desired view of the target, using the <i>PlayerDummy</i> node as its base.</p>
			<p>Input is handled via the <i>CameraControls.cs</i> component and allows orbiting around the target as well as zooming in and out. The behavior is configurable through parameters such as <i>Angular Speed, Zoom Speed, Min/Max Distance, Min/Max Vertical Angle</i>, and the <i>Use Fixed Angles</i> toggle. The <i>Target</i> field can be manually assigned and defines the object the camera will follow.</p>
			<p>The target movement is defined by the <i>CameraPersecutorTarget.cs</i> component, which moves the object along a circular path over time to demonstrate dynamic tracking.</p>
		]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
			<p><b>Move Mouse</b> - Rotate the camera around the target</p>
			<p><b>Mouse Wheel</b> - Zoom in and out</p>
		]]>
	</controls>
	<tags>
		<tag>Cameras</tag>
		<tag>Logic</tag>
		<tag>Input &amp; Controls</tag>
	</tags>
</sample>
<sample title="Spectator Controller" id="spectator_controller" category_id="player_controllers">
	<sdk_desc><![CDATA[Implementation of a customizable first-person spectator camera with configurable movement and physical collision detection.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample implements a first-person <b>Spectator camera</b> controller with configurable movement and physical collision detection using the <b>Sphere collision shape</b>, assigned to respond to collisions with geometry (e.g. with terrain) in the world.</p>
			<p>Movement parameters such as speed, sprint acceleration, turning rate, and mouse sensitivity can be adjusted in real-time using the sliders in the <i>Parameters</i> section.</p>
			<p><b>Use Cases:</b></p>
									<p> - Building custom camera tools with physical awareness for scene editing or testing purposes.</p>
					<p> - First-person 3D scenes navigation and exploring while preserving configurable interaction with the geometry.</p>
						]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
		<p><b>W/A/S/D, Q/E</b>: control camera movement</p>
		<p><b>Shift</b>: accelerate</p>
		<p><b>Mouse movement or Arrow keys</b>: look around</p>
		]]>
	</controls>
	<tags>
		<tag>Complex Solutions</tag>
		<tag>Cameras</tag>
		<tag>Physics</tag>
	</tags>
</sample>
<sample title="Top-Down Controller" id="top_down_controller" category_id="player_controllers">
	<sdk_desc><![CDATA[Implementation of some elements of a top-down strategy such as selecting one or multiple units, panning the view, turning the camera and smoothly focusing it on the current selection.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[This sample demonstrates how to set up and control a top-down camera controller for real-time strategy or tactics-style gameplay. It implements core features typical for such games, including camera movement, zooming, rotation, edge scrolling, unit selection, and focus tracking.]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
<p>Use <b>Left Mouse Button</b> to select objects.</p>
<p>Use <b>Middle Mouse Button</b> to move the camera.</p>
<p>Use <b>Mouse Wheel</b> to zoom the camera.</p>
<p>Use <b>Q</b> and <b>E</b> to rotate the camera.</p>
<p>Hold <b>F</b> to follow selected objects.</p>
		]]>
	</controls>
	<tags>
		<tag>Complex Solutions</tag>
		<tag>Cameras</tag>
		<tag>Games</tag>
	</tags>
</sample>
<sample title="Clutter To Cluster Converter" img="yes" id="clutter_to_cluster_converter" category_id="procedural_generation_placement">
	<sdk_desc><![CDATA[Dynamic generation of a <i>Mesh Clutter</i> and its conversion into a performance-optimized <i>Mesh Cluster</i> at runtime.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to dynamically generate a clutter (<b>ObjectMeshClutter</b>) and convert it into an optimized cluster (<b>ObjectMeshCluster</b>) in real time. The clutter is generated using a random seed, and the conversion process transfers all key parameters from the clutter: materials, surface properties, LOD, shadows, physics, and collision settings.</p>
			<p>The resulting cluster inherits the clutter's transform and hierarchy, but lets you <b>selectively edit and remove individual elements</b> of the group. Very often when building your worlds it is necessary to scatter meshes across a certain area randomly and then reposition some of them manually (e.g. when creating forests).</p>
			<p><b>UI Features:</b></p>
							<p> - <b>Generate Clutter</b> - Creates a randomized layout of clutter meshes.</p>
				<p> - <b>Convert to Cluster</b> - Merges all clutter instances into a single <b>ObjectMeshCluster</b> with identical visual/physical behavior.</p>
					]]>
		</brief>
	</desc>
	<tags>
		<tag>Optimization</tag>
		<tag>Objects</tag>
		<tag>World Management</tag>
	</tags>
</sample>
<sample title="Grid-Based Node Spawning" id="grid_based_node_spawning" category_id="procedural_generation_placement">
	<sdk_desc><![CDATA[Spawning nodes across a grid.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample shows how to create nodes and place them across a configurable grid.</p>
			<p>Adjust grid dimensions, cell size, and toggle between spawning from corner or center pivot. The system automatically clears and regenerates the entire grid when parameters are changed, providing real-time visualization of layout modifications.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Nodes</tag>
		<tag>Basics</tag>
		<tag>Basic Recipes</tag>
	</tags>
</sample>
<sample title="Procedural Mesh Generation" id="procedural_mesh_generation" category_id="procedural_generation_placement">
	<sdk_desc><![CDATA[Demonstrating runtime procedural mesh generation, along with visualization of how different procedural modes impact memory usage during creation and rendering.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to generate static mesh geometry at runtime using different procedural mesh generation methods. A grid of <i>ObjectMeshStatic</i> objects is created, each receiving its geometry from a user-defined callback that builds a box-shaped mesh surface via the <i>Mesh API</i>.</p>
			<p>You can experiment with various procedural modes (such as <i>Dynamic, File</i>, or <i>Blob</i>), as well as configure how geometry is stored and accessed by selecting different MeshRender usage flags (DirectX 12 only). These flags determine whether vertex and/or index data is kept in RAM instead of VRAM, allowing the GPU to render directly from system memory.</p>
							<p> - <b>Dynamic</b> - fastest performance, stored in RAM and VRAM, not automatically unloaded from memory.</p>
				<p> - <b>Blob</b> - moderate performance, stored in RAM and VRAM, automatically unloaded from memory.</p>
				<p> - <b>File</b> - slowest performance, all data stored on disk, automatically unloaded from memory.</p>
						<p>The <b>Field Size</b> parameter defines how many mesh objects are generated along each axis, forming a square grid.</p>
			<p>For each configuration, the sample shows total RAM and VRAM usage, along with the number of active mesh objects. This makes it easier evaluate the performance, memory layout, and behavior of each procedural mode in different runtime conditions.</p>
		]]>
		</brief>
	</desc>
	<link_docs>https://developer.unigine.com/docs/api/library/objects/class.objectmeshstatic?rlang=cs#procedural_workflow</link_docs>
	<tags>
		<tag>Systems</tag>
		<tag>Objects</tag>
		<tag>Procedural</tag>
		<tag>Mesh</tag>
	</tags>
</sample>
<sample title="Procedural Mesh Modification" id="procedural_mesh_modification" category_id="procedural_generation_placement">
	<sdk_desc><![CDATA[Demonstrating runtime procedural mesh modification, along with visualization of how different procedural modes impact streamiing and memory usage during creation and rendering.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to dynamically generate, modify, and apply procedural geometry at runtime using different procedural mesh modification methods.</p>
			<p>The dynamic surface mesh being built and animated over time using trigonometric functions. The geometry is rebuilt each frame depending on current configuration.</p>
			<p>You can experiment with various procedural modes (such as <i>Dynamic, File</i>, or <i>Blob</i>), as well as configure how geometry is stored and accessed by selecting different MeshRender usage flags (DirectX 12 only). These flags determine whether vertex and/or index data is kept in RAM instead of VRAM, allowing the GPU to render directly from system memory.</p>
			<p>Additionally, you can choose whether mesh generation occurs on the <b>Main</b> thread or in the <b>Background</b>, giving you more control over performance and responsiveness during updates.</p>
							<p> - <b>Dynamic</b> - fastest performance, stored in RAM and VRAM, not automatically unloaded from memory.</p>
				<p> - <b>Blob</b> - moderate performance, stored in RAM and VRAM, automatically unloaded from memory.</p>
				<p> - <b>File</b> - slowest performance, all data stored on disk, automatically unloaded from memory.</p>
						<p>You can also toggle between different update modes (<i>Async</i> or <i>Force</i>), choose memory transfer strategies (<i>Copy</i> or <i>Move</i>), and optionally enable manual control of the <i>MeshRender</i>, where you update its content explicitly after modifying mesh data, instead of relying on automatic updates. Additionally, collision data can be generated explicitly after geometry modification, as it is not created automatically.</p>
		]]>
		</brief>
	</desc>
	<link_docs>https://developer.unigine.com/en/docs/api/library/objects/class.objectmeshstatic?rlang=cs#procedural_workflow</link_docs>
	<tags>
		<tag>Systems</tag>
		<tag>Objects</tag>
		<tag>Procedural</tag>
		<tag>Mesh</tag>
	</tags>
</sample>
<sample title="Procedural Mesh Updates Mesh Clusters" id="procedural_mesh_updates_mesh_clusters" category_id="procedural_generation_placement">
	<sdk_desc><![CDATA[A minimal example that shows how to generate and apply a procedural mesh at runtime using the correct update sequence.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates the correct order of operations for modifying and applying procedural mesh data at runtime. It serves as a minimal example showing how to build geometry, configure procedural mode, and apply changes to an <i>ObjectMeshCluster</i>.</p>
			<p>The same workflow and apply methods are also available for other objects that support procedural meshes, such as <i>ObjectMeshStatic</i>, <i>ObjectGuiMesh</i>, <i>DecalMesh</i>, and <i>ObjectMeshClutter</i>.</p>
			<p>Inside the component's code, you'll find a linear implementation of the procedural mesh pipeline, demonstrating how geometry is generated and applied in the correct order.</p>
			<p>Use this sample to understand the basic flow of procedural mesh updates and try adjusting configurations to find what best suits your needs.</p>
		]]>
		</brief>
	</desc>
	<link_docs>https://developer.unigine.com/docs/api/library/objects/class.objectmeshstatic?rlang=cs#procedural_workflow</link_docs>
	<tags>
		<tag>Systems</tag>
		<tag>Objects</tag>
		<tag>Procedural</tag>
		<tag>Mesh</tag>
	</tags>
</sample>
<sample title="Procedural Spline Mesh Generation" id="procedural_spline_mesh_generation" category_id="procedural_generation_placement">
	<sdk_desc><![CDATA[Procedural generation of spline-based meshes from world points with real-time parameter control.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates procedural generation of spline-based meshes using world points as control nodes. The system creates three geometric types: <b>RIBBON, SQUARE PIPE</b>, and <b>ROUND PIPE</b>, with adjustable width, subdivision level, and segment length. UV mapping parameters allow texture tiling and stretching control along both length and width.</p>
			<p>The generated mesh updates in real-time as control points are manipulated (supporting movement along single axes or planar constraints), with a visualizer showing the spline path and wireframe. An interactive interface provides controls for all generation parameters and mesh type switching.</p>
		]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
			<b>LMB</b> - Select object.<br/>
			<b>LMB (drag)</b> - Move object.<br/><br/>
			<b>F</b> - Focus on selected object.<br/>
			<b>U</b> or <b>ESC</b> - Deselect object.
		]]>
	</controls>
	<tags>
		<tag>Complex Solutions</tag>
		<tag>Mesh</tag>
	</tags>
</sample>
<sample title="Real-Time Mesh Editing with Marching Cubes" id="real_time_mesh_editing_marching_cubes" category_id="procedural_generation_placement">
	<sdk_desc><![CDATA[Simulation of the ground digging process based on mesh geometry modification.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates a simulation of ground digging, modification of a terrain fragment represented by a mesh via API. The fragment of the ground surfaces is generated using the Marching Cubes algorithm.</p>
			<p>Click <b>LMB</b> to dig the ground at a certain point (the cutting sphere is visualized around the cursor). Set the desired radius of the cutting sphere (<i>Digging Radius</i>) defining the volume of ground to be removed.</p>
			<p><b>Hold Ctrl + LMB</b> to add volume instead.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Complex Solutions</tag>
		<tag>Procedural</tag>
		<tag>Mesh</tag>
		<tag>Sim</tag>
	</tags>
</sample>
<sample title="Timer-Based Node Spawning" id="timer_based_node_spawning" category_id="procedural_generation_placement">
	<sdk_desc><![CDATA[Implementing a simple node spawner that creates nodes at a set spawn frequency.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates a configurable node spawner that creates objects at defined intervals. The spawn frequency can be adjusted in real-time, with a visual indicator showing the current spawn cycle progress through a color-changing sphere.</p>
			<p>The sample will be useful for generating game objects with a certain periodicity - for example, enemies, bonuses, effects or other elements of the game world.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Basic Recipes</tag>
		<tag>Procedural</tag>
	</tags>
</sample>
<sample title="Camera To Texture" id="camera_to_texture" category_id="rendering">
	<sdk_desc><![CDATA[Capturing a camera's output in real time and projecting it onto a material's albedo texture using <i>Viewport.RenderTexture2D()</i>.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample shows how to capture the output of a camera in real time and project it onto a material's albedo texture using <i>Viewport.RenderTexture2D()</i>.</p>
			<p>A renderable 2D texture is created and set as the albedo texture of the material assigned to the plane. Each frame, the active camera's view is rendered into this texture, updating the appearance of the object it's applied to. Texture sampling settings like linear filtering and anisotropy are configured to ensure visual quality. The UV transform is also adjusted to correct for platform-dependent flipping.</p>
			<p>This method can be used for features such as security monitors, live camera feeds, dynamic mirrors, portals, or mini-maps in your worlds.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Render</tag>
		<tag>Materials</tag>
	</tags>
</sample>
<sample title="FFP Triangle Fan Rendering" id="ffp_triangle_fan_rendering" category_id="rendering">
	<sdk_desc><![CDATA[Using FFP functionality to draw simple 2D shapes over the rendered image without any additional shaders.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to render a simple 2D shape using the <i>Fixed Function Pipeline (Ffp)</i> in UNIGINE via the C# API. A colorful figure composed of 16 vertices is drawn directly on screen using orthographic projection.</p>
			<p>The rendering logic is called every frame by hooking into the Engine's render loop. Ffp mode is enabled for drawing and then disabled, keeping this rendering isolated from the rest of the frame.</p>
			<p>This approach is useful for quick visualization overlays, Editor tools, or debugging tasks where shader-based rendering isn't required.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Systems</tag>
		<tag>Rendering</tag>
	</tags>
</sample>
<sample title="Gui To Texture" id="gui_to_texture" category_id="rendering">
	<sdk_desc><![CDATA[Rendering GUI onto texture using <i>Gui.Render()</i>.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to render GUI elements into a texture using <i>Gui.Render()</i>. Instead of drawing directly to the screen, the GUI is redirected to a custom framebuffer, which isolates its rendering pipeline and allows the resulting texture to be applied to materials.</p>
			<p>You can use this sample to display dynamic GUI elements on in-game monitors, control panels, or other similar surfaces.</p>
			<p>The <b>GuiToTexture</b> component supports two update modes:</p>
							<p> - In manual mode, the texture is updated only when explicitly calling <i>RenderToTexture()</i> method. This is used in the <b>WidgetClock</b> component, where the GUI (a digital clock) is re-rendered once per second, only when the displayed time changes.</p>
				<p> - Automatic mode is enabled by default and updates the GUI texture every frame. This is demonstrated in the <b>WidgetNoSignal</b> component, where a <i>'No Signal'</i> label moves across the screen like a screensaver. Because the position of the widget changes every frame, the texture must be continuously updated to reflect those changes.</p>
					]]>
		</brief>
	</desc>
	<tags>
		<tag>Render</tag>
		<tag>Materials</tag>
	</tags>
</sample>
<sample title="Mesh To Mask Texture" id="mesh_to_mask_texture" category_id="rendering">
	<sdk_desc><![CDATA[Rendering a mesh into a texture using a custom material for mask generation.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to render a mesh into a texture using a custom material, producing an image to be used as a mask. The mesh is rendered from a dedicated camera view directly into a texture, which is then assigned to the albedo slot of a preview material.</p>
			<p>Use the manipulator to move the camera view and observe how different viewing angles affect the generated texture mask.</p>
			<p>The sample compares two rendering approaches:</p>
							<p> - <b>Renderer.RenderMesh</b> - standard camera-based rendering <b>(recommended for most use cases)</b>. The Engine automatically prepares matrices, render states, and shaders, so you only need to provide the mesh, material, transform, and camera.</p>
				<p> - <b>MeshRender.Render</b> - low-level, <b>fully manual</b> projection and modelview setup. This method provides finer control over the rendering pipeline but requires explicit setup of projection and view matrices, RenderState configuration, and manual shader parameter management.</p>
						<p>Both methods produce identical visual results, allowing you to choose whichever approach best fits your workflow.</p>
			<p>This technique is useful for dynamic decals, procedural effects, or any feature requiring real-time texture generation from 3D geometry.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Render</tag>
		<tag>Materials</tag>
		<tag>Mesh</tag>
	</tags>
</sample>
<sample title="Procedural 3D Volume Texture Generation" id="procedural_3d_volume_texture_generation" category_id="rendering">
	<sdk_desc><![CDATA[Procedurally generate <i>3D</i> image data and use it as a density texture for a volume-based material in real time.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample shows how to procedurally generate <i>3D</i> image data and use it as a density texture for a volume-based material in real time. The result is visualized using a volume box that updates dynamically every frame based on custom field simulation.</p>
			<p>The sample initializes a <i>3D</i> image with a predefined resolution and fills it with voxel data derived from a set of moving fields. Each field represents an abstract spherical influence zone that contributes to the voxel density based on distance. Field dynamics are updated every frame to simulate motion.</p>
			<p>The raw image data is accessed directly via a pixel pointer and modified per frame, with density values mapped to <i>RGBA</i> channels. The resulting image is then uploaded to a material as a <i>3D</i> texture used in a volumetric shading model.</p>
			<p>The sample demonstrates how to work with the <i>Image</i> class and update <i>GPU</i> resources efficiently at runtime. This approach can be used for generating volumetric effects such as clouds, fog, or procedurally driven visual phenomena.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Render</tag>
		<tag>Procedural</tag>
	</tags>
</sample>
<sample title="Screenshot" id="screenshot" category_id="rendering">
	<sdk_desc>
		<![CDATA[Simple demonstration of how to make a screenshot by grabbing the final image from the rendering sequence.]]>
	</sdk_desc>
	<desc>
		<brief>
		<![CDATA[Simple demonstration of how to make a screenshot by grabbing the final image from the rendering sequence.]]>
		</brief>
	</desc>
	<tags>
		<tag>Render</tag>
		<tag>Basic Recipes</tag>
	</tags>
</sample>
<sample title="Visualizer" id="visualizer" category_id="rendering">
	<sdk_desc><![CDATA[Demonstration of the full range of features provided by the <i>Visualizer</i> class for visual debugging.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates the full range of features provided by the <i>Visualizer</i> class.</p>
			<p>The sample illustrates how to use <i>Visualizer</i> for debugging node positions, physics vectors, bounding volumes, and custom geometry in both world space and screen space. Use controls to explore the area.</p>
			<p><i>VisualizerUsage.cs</i> renders a wide range of primitives including points, lines, boxes, frustums, spheres, capsules, and object bounds using <i>Visualizer</i> methods.</p>
			<p><i>2D</i> visualizer features can be toggled on and off via the corresponding checkboxes.</p>
			<p>Enable or disable depth testing, toggle specific primitives, and inspect how different rendering options behave in real time.</p>
		]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
		<p><b>W,A,S,D</b> - Camera movement</p>
		<p><b>LMB</b> - Camera rotation</p>
		<p><b>Left Shift</b> - Camera acceleration</p>
		]]>
	</controls>
	<tags>
		<tag>Visualizer (Visual Debug)</tag>
	</tags>
</sample>
<sample title="Weapon Clipping" id="weapon_clipping" category_id="rendering">
	<sdk_desc><![CDATA[Rendering the weapon from a second camera into a texture to avoid clipping issues.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>In first-person games, weapon models can clip through walls or geometry when the camera gets too close. This sample solves the problem by rendering the weapon separately into a texture and overlaying it on top of the main camera view.</p>
			<p>This approach keeps the weapon always visible, even when the camera is close to walls, without interfering with the main rendering pipeline.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Render</tag>
		<tag>Cameras</tag>
		<tag>Games</tag>
		<tag>Basic Recipes</tag>
	</tags>
</sample>
<sample title="Bounding Box Object Detection" id="bounding_box_object_detection" category_id="scene_management">
	<sdk_desc><![CDATA[Finding an intersection between the bound box and geometry.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to find an intersection between the bound box and geometry.</p>
			<p>The <i>BoundBoxIntersection.cs</i> component shows how to use <i>World.GetIntersection()</i> to detect static mesh objects located within a specified world-space axis-aligned bounding box. The box is highlighted using the <i>Visualizer</i>, and intersected object names are printed to the onscreen console overlay.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Intersections</tag>
	</tags>
</sample>
<sample title="Bounding Frustum Object Detection" id="bounding_frustum_object_detection" category_id="scene_management">
	<sdk_desc><![CDATA[Finding an intersection between the bound frustum and geometry.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to find an intersection between the bound frustum and geometry.</p>
			<p>The <i>BoundFrustumIntersection.cs</i> component shows how to use <i>World.GetIntersection()</i> to detect static mesh objects located inside a perspective frustum defined in world coordinates. The frustum is highlighted using the <i>Visualizer</i>, and intersected object names are printed to the onscreen console overlay.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Intersections</tag>
	</tags>
</sample>
<sample title="Bounding Sphere Object Detection" id="bounding_sphere_object_detection" category_id="scene_management">
	<sdk_desc><![CDATA[Finding an intersection between the bound sphere and geometry.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to find an intersection between the bound sphere and geometry.</p>
			<p>The <i>BoundSphereIntersection.cs</i> component shows how to use <i>World.GetIntersection()</i> to detect static mesh objects located within a spherical volume defined in world coordinates. The sphere is highlighted using the <i>Visualizer</i>, and intersected object names are printed to the onscreen console overlay.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Intersections</tag>
	</tags>
</sample>
<sample title="Create Mesh Primitives" id="create_mesh_primitives" category_id="scene_management">
	<sdk_desc><![CDATA[Creating parametric 3D primitives at runtime.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to create parametric 3D primitives at runtime in UNIGINE.</p>
			<p>It showcases the use of the <b>Mesh</b> class and <b>ObjectMeshDynamic</b> nodes to procedurally generate a variety of basic shapes (<b>Box, Sphere, Cylinder, Capsule, Prism with a custom number of sides</b> and <b>Plane</b>) via code.</p>
			<p>Each shape is constructed with a customizable size and resolution, added to a mesh surface, and placed in the world at a designated position.</p>
			<p>This approach allows dynamic geometry generation for tools, Editor extensions, procedural environments, and rapid prototyping.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Objects</tag>
		<tag>Mesh</tag>
		<tag>Procedural</tag>
	</tags>
</sample>
<sample title="Day-Night Cycle" id="day_night_cycle" category_id="scene_management">
	<sdk_desc><![CDATA[Implementation of an automated day-night system with light and material switching.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample showcases a dynamic day-night cycle driven by the rotation of a <b>World Light</b> source (sun), animated according to a simulated global time. The sun's position is updated continuously or in response to manual time input. The time progression speed can be adjusted using the <i>Timescale</i> slider.</p>
			<p>The sun's orientation influences both the overall scene lighting and object-specific responses, enabling or disabling nodes and adjusting the emission states of designated materials depending on whether it's currently day or night. Additional props, such as <b>Projected Light</b> node and door closed/open signage, are toggled to reflect the time of day. Red and blue helper vectors visualize the zenith direction and the sun's current orientation, respectively.</p>
			<p><b>Two control modes are available:</b></p>
									<p> - <b>Zenith Angle</b>: Uses the angle between the sun's direction and the zenith (up vector). If the angle is below a threshold, it is considered daytime.</p>
					<p> - <b>Time-Based</b>: Defines day/night using configurable <i>Morning</i> and <i>Evening hour boundaries</i> sliders.</p>
							<p><b>Use Cases:</b></p>
			<p>Ideal for <b>games, simulations</b>, or <b>architectural walkthroughs</b> that need consistent lighting transitions and dynamic environmental response.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Complex Solutions</tag>
		<tag>Environment</tag>
		<tag>Lighting</tag>
	</tags>
</sample>
<sample title="Local vs World Space Transforms" id="local_vs_world_space_transforms" category_id="scene_management">
	<sdk_desc><![CDATA[Demonstration of the difference between local and world transformations.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates the difference between local and world transformations. Local transformations are affected by the object's current orientation (movement follows rotation), while world transformations remain consistent regardless of rotation (movement in fixed global directions).</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Basics</tag>
		<tag>Basic Recipes</tag>
		<tag>Transformations</tag>
	</tags>
</sample>
<sample title="Move By Trajectory" id="move_by_trajectory" category_id="scene_management">
	<sdk_desc><![CDATA[Three types of movement along a predefined path: linear interpolation, spline interpolation, and a trajectory loaded from a <b>*.path</b> file.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates three types of movement along a predefined path:</p>
							<p> - <b>Red plane</b>: linear interpolation.</p>
				<p> - <b>Blue plane</b>: spline interpolation.</p>
				<p> - <b>Green plane</b>: path from a file.</p>
						<p>The sample contains the <i>PathTrajectorySaver</i> component that illustrates how to create your own path file, which is opened via the <i>WorldTransformPath</i> node.</p>
			<p>In the Parameters section, you can toggle path visualization on and off, adjust the planes' velocity, or switch between the cameras to have a first-person view from each plane.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Nodes</tag>
		<tag>Basics</tag>
		<tag>Basic Recipes</tag>
		<tag>Transformations</tag>
	</tags>
</sample>
<sample title="Nodes And Widgets Lifetime Control" id="nodes_and_widgets_lifetime_control" category_id="scene_management">
	<sdk_desc><![CDATA[Implementation of configurable node and widget lifetimes with persistence across different worlds.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how node and widget lifetime settings affect object persistence during world transitions.</p>
			<p>At startup, the sample creates a plane node and a screen button, each with configurable lifetime modes. Switch the widget between <b>WORLD</b> and <b>WINDOW</b> lifetime modes, and the node between <b>WORLD</b> and <b>ENGINE</b> modes.</p>
			<p>Use the <b>world_load world_name</b> console command (e.g., <b>world_load arcade</b>) to switch worlds and observe how different lifetime settings affect object survival. <i>WORLD-lifetime</i> objects exist only in the current world, while <i>ENGINE-lifetime</i> nodes and <i>WINDOW-lifetime</i> widgets remain active after loading a different world.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Basics</tag>
	</tags>
</sample>
<sample title="Node Movement" id="node_movement" category_id="scene_management">
	<sdk_desc><![CDATA[Implementing object movement and rotation in 3D space using three different methods.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[		<p>This sample compares three approaches to object movement and rotation using different node transformation methods, and illustrates that using either of them leads to the same result:</p>
		<p><b>Red cube</b> is controlled using <i>Translate()</i> and <i>Rotate()</i>.</p>
		<p><b>Green cube</b> uses <i>Position()</i> and <i>SetRotation()</i>.</p>
		<p><b>Blue cube</b> uses <i>Transform()</i>.</p>
		]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
<b>WASD</b> - to move and rotate the boxes.<br/>
		]]>
	</controls>
	<tags>
		<tag>Basic Recipes</tag>
		<tag>Transformations</tag>
	</tags>
</sample>
<sample title="Node Spawning And Deletion" id="node_spawning_and_deletion" category_id="scene_management">
	<sdk_desc><![CDATA[Dynamic creation and deletion of node instances at runtime.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to dynamically create and delete node instances at runtime in UNIGINE.</p>
			<p>A specified <b>.node</b> asset is instantiated repeatedly at timed intervals, with each new instance positioned in a grid pattern. Once a certain number of nodes are active, the oldest ones are automatically removed (first-in, first-out deletion) to maintain a fixed, memory-safe maximum count in the scene.</p>
			<p><b>Use Cases:</b></p>
							<p> - Object pooling and controlled instancing</p>
				<p> - Spawning projectiles, enemies, or temporary effects.</p>
					]]>
		</brief>
	</desc>
	<tags>
		<tag>Objects</tag>
		<tag>Optimization</tag>
	</tags>
</sample>
<sample title="Raycast Detection And Bitmasking" id="raycast_detection_and_bitmasking" category_id="scene_management">
	<sdk_desc><![CDATA[Finding an intersection of a ray with geometry.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to find an intersection of a ray with geometry.</p>
			<p>The <i>LaserRayIntersection.cs</i> component casts a ray from the laser origin in its forward direction and uses <i>World.GetIntersection()</i> to detect intersections with geometry. The method provides both the intersection point and the surface normal. Intersected object names are printed to the onscreen console overlay.</p>
			<p>If a hit is detected, the laser beam is resized to visually represent the exact distance between its origin and the intersection point. The hit effect object is shown at the intersection point, oriented in accordance with the surface normal. If no intersection is found, the laser beam keeps its default length and the effect remains hidden.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Intersections</tag>
	</tags>
</sample>
<sample title="Raycast From Mouse Position" id="raycast_from_mouse_position" category_id="scene_management">
	<sdk_desc><![CDATA[Finding an intersection between a ray cast from the camera through the mouse cursor and geometry.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to find an intersection between a ray cast from the camera through the mouse cursor and geometry.</p>
			<p>The <i>MouseRayIntersection.cs</i> component shows how to use <i>World.GetIntersection()</i> to detect static mesh objects intersected by a ray cast from the player's position in the direction pointed by the mouse cursor.</p>
			<p>The name of the hit object is displayed next to the cursor on the screen.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Intersections</tag>
	</tags>
</sample>
<sample title="Trigger System Examples" id="trigger_system_examples" category_id="scene_management">
	<sdk_desc><![CDATA[Implementation of various types of triggers.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample illustrates how to implement a simple trigger component in five different ways:</p>
							<p> - <b>Intersection Trigger</b> performs the bound check via <i>World.GetIntersection()</i>.</p>
				<p> - <b>Math Trigger</b> performs the check if the object is inside the trigger sphere or cube using the object coordinates (the simplest and most performance-friendly way).</p>
				<p> - <b>World Trigger</b> uses the built-in <i>WorldTrigger</i> node, which automatically detects when nodes enter or leave a predefined volume.</p>
				<p> - <b>Physical Trigger</b> uses the built-in <i>PhysicalTrigger</i> node, triggers events when a physical object gets inside or outside it. To be detected by the trigger, physical objects are required to have at the same time both a body and a shape.</p>
				<p> - 					<p><b>Node Trigger</b> uses the built-in <i>NodeTrigger</i> node, which has no visual representation and triggers events when being enabled or moved.</p>
					<p>Press <i>Cube Active</i> to see Node Trigger in action. This checkbox toggles the demonstration cube on/off, triggering enable/disable events that change the plate text color and animate the cube's material when it's moved with a manipulator (click the cube for the manipulator to appear).</p>
				</p>
					]]>
		</brief>
	</desc>
	<tags>
		<tag>Triggers</tag>
		<tag>Logic</tag>
	</tags>
</sample>
<sample title="FMOD Core" id="fmod_core" category_id="sounds">
	<sdk_desc><![CDATA[
		<p><b>FMOD Core</b> integration for real-time playback of 2D and 3D sounds with timeline control and DSP effects.</p>
		<p><br/><b>NOTICE: Additional libraries are required, run the sample for details.</b></p>
	]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>Before running this sample, follow the steps provided in the setup section or in the FMOD Integration Guide linked below.</p>
			<p>This sample loads the <i>FMOD</i> plugin and initializes the <i>Core</i> system to demonstrate playback of both 2D and 3D sound instances, supporting up to <b>1024</b> simultaneous sound channels. You can switch between the 2D and 3D scenes to observe and interact with different sound behaviors.</p>
			<p>Two sound modes are presented:</p>
							<p> - <b>2D Music Playback</b>: Standard audio playback with support for volume adjustment and a distortion DSP effect</p>
				<p> - <b>3D Music Playback</b>: Sound is emitted from a red sphere in 3D space, demonstrating positional audio in the environment. Move the camera to experience changes in sound direction and attenuation in real time.</p>
						<p><b>Use Cases:</b></p>
							<p> - Integrating FMOD Core into runtime environments for games or simulations</p>
				<p> - Prototyping spatial sound design and 3D audio placement.</p>
						<p><br/><br/><b>Sample Requirements</b><br/></p>
			<p>1. Download and install <b>FMOD Engine (version 2.03.08)</b> for your OS available on the official website (<b>https://www.fmod.com/download</b>).<br/><br/></p>
			<p>2. Go to the FMOD installation folder and copy the following files to the <b>bin</b> folder of your project:<br/></p>
			<p><br/><b>for Windows:</b></p>
									<p> - <b>fmod.dll, fmodL.dll</b> from <b>/api/core/lib/x64/</b></p>
					<p> - <b>fsbank.dll, libfsbvorbis64.dll, opus.dll</b> from <b>/api/fbank/lib/x64/</b>.</p>
					<p> - <b>fmodstudio.dll, fmodstudioL.dll</b> from <b>/api/studio/lib/x64/</b></p>
							<p><br/><b>for Linux</b></p>
									<p> - <b>libfmod.so.13, libfmodL.so.13</b> from <b>/api/core/lib/x64/</b></p>
					<p> - <b>libfsbank.so.13, libfsbankL.so.13, libfsbvorbis.so, libopus.so</b> from <b>/api/fbank/lib/x64/</b></p>
					<p> - <b>libfmodstudio.so.13, libfmodstudioL.so.13</b> from <b>/api/studio/lib/x64/</b></p>
						]]>
		</brief>
	</desc>
	<link_docs>https://developer.unigine.com/docs/code/plugins/fmod/index?rlang=cpp</link_docs>
	<tags>
		<tag>Sound</tag>
		<tag>Plugins</tag>
		<tag>Integration</tag>
		<tag>Extension &amp; Customization</tag>
	</tags>
</sample>
<sample title="FMOD Studio" id="fmod_studio" category_id="sounds">
	<sdk_desc><![CDATA[
		<p><b>FMOD Studio</b> integration with real-time interactive audio effects, spatialization, and Doppler effect simulation.</p>
		<p><br/><b>NOTICE: Additional libraries are required, run the sample for details.</b></p>
	]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>Before running this sample, follow the steps provided in the setup section or in the FMOD Integration Guide linked below.</p>
			<p>This sample demonstrates how to control, simulate, and visualize real-time audio events using the <i>FMOD Studio</i> plugin.</p>
			<p>The setup includes a stationary object (car) and a moving object representing a source of Doppler-shifted sound, which can be toggled and adjusted via the <i>Doppler</i> tab of the GUI Parameters section. Additional sound settings such as wind, rain, the car engine RPM sound, and overall environmental volume can also be fine-tuned in real time under the <i>Ambience</i>, <i>Engine</i>, and <i>VCA</i> tabs.</p>
			<p><b>Use Cases:</b></p>
							<p> - Prototyping audio-driven game mechanics (e.g., vehicle audio, spatial ambiences, Doppler effects)</p>
				<p> - Demonstrating dynamic audio parameters and movement-based effects like Doppler shifts.</p>
						<p><br/><br/><b>Sample Requirements</b><br/></p>
			<p>1. Download and install <b>FMOD Engine (version 2.03.08)</b> for your OS available on the official website (<b>https://www.fmod.com/download</b>).<br/><br/></p>
			<p>2. Go to the FMOD installation folder and copy the following files to the <b>bin</b> folder of your project:<br/></p>
			<p><br/><b>for Windows:</b></p>
									<p> - <b>fmod.dll, fmodL.dll</b> from <b>/api/core/lib/x64/</b></p>
					<p> - <b>fsbank.dll, libfsbvorbis64.dll, opus.dll</b> from <b>/api/fbank/lib/x64/</b>.</p>
					<p> - <b>fmodstudio.dll, fmodstudioL.dll</b> from <b>/api/studio/lib/x64/</b></p>
							<p><br/><b>for Linux</b></p>
									<p> - <b>libfmod.so.13, libfmodL.so.13</b> from <b>/api/core/lib/x64/</b></p>
					<p> - <b>libfsbank.so.13, libfsbankL.so.13, libfsbvorbis.so, libopus.so</b> from <b>/api/fbank/lib/x64/</b></p>
					<p> - <b>libfmodstudio.so.13, libfmodstudioL.so.13</b> from <b>/api/studio/lib/x64/</b></p>
						]]>
		</brief>
	</desc>
	<link_docs>https://developer.unigine.com/docs/code/plugins/fmod/index?rlang=cpp</link_docs>
	<tags>
		<tag>Sound</tag>
		<tag>Plugins</tag>
		<tag>Integration</tag>
		<tag>Extension &amp; Customization</tag>
	</tags>
</sample>
<sample title="Sound Ambient" id="sound_ambient" category_id="sounds">
	<sdk_desc><![CDATA[Playing ambient sounds via code.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample shows the implementation of a component that controls the playback of ambient sound (<i>AmbientSource</i>) with interactive GUI controls using the <i>AmbientSource</i> class. The component creates an ambient sound source that plays continuously in the background and provides real-time parameter adjustment through a dedicated interface.</p>
			<p>The streaming mode can be toggled dynamically via the <i>Stream</i> checkbox, recreating the sound source to switch between preloaded audio (lower latency) and streamed audio (lower memory usage). This approach is ideal for background music, environmental sounds, and other continuous audio elements that enhance scene immersion.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Sound</tag>
	</tags>
</sample>
<sample title="Sound Reverb" id="sound_reverb" category_id="sounds">
	<sdk_desc><![CDATA[Setting a reverberation zone and its parameters via code.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates a <i>Reverberation Zone</i> controller that uses the SoundReverb component to create configurable acoustic areas. These zones affect sound sources within their boundaries, simulating realistic environmental reverberation that adds depth and authenticity to audio experiences.</p>
			<p>Adjust the <i>Gain</i> slider in the Parameters section to control various reverb properties, including density, decay time, and reflection gain.</p>
			<p>Visual boundaries clearly delineate the affected areas, enabling precise spatial control over acoustic effects throughout the scene.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Sound</tag>
	</tags>
</sample>
<sample title="Sound Source 3D" id="sound_source_3d" category_id="sounds">
	<sdk_desc><![CDATA[Playing a sound source via code.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This example demonstrates how to create a sound source (<i>SoundSource</i>) and configure its basic parameters: volume, pitch, looping mode, and playback type. The sound source features configurable spatial audio properties with adjustable minimum and maximum distance falloff, visualized in the scene.</p>
			<p>UNIGINE allows you to work with sound sources just like with other nodes: they can be easily moved, rotated, or scaled. Additionally, they have specific characteristics detailed in the related article.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Sound</tag>
	</tags>
</sample>
<sample title="Polygon-Based Tools for Procedural Modifications" id="polygon_based_procedural_modifications" category_id="terrain_modification_usage">
	<sdk_desc><![CDATA[Procedural polygon objects generation based on world points for landscape editing and object placement.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates procedural generation of polygon objects from world points, enabling runtime landscape editing and object placement.</p>
			<p>It dynamically creates polygonal geometry and applies it in multiple contexts:</p>
							<p> - <b>ObjectMeshStatic</b> - creates <i>ObjectMeshStatic</i> and places it at the center of the <i>WorldBoundBox</i> formed by the points.</p>
				<p> - <b>DecalMesh</b> - creates <i>DecalMesh</i> and places it at the center of the <i>WorldBoundBox</i> formed by the points.</p>
				<p> - <b>DecalOrtho</b> - renders mesh into a texture applied to the albedo slot of <i>DecalOrtho</i> material.</p>
				<p> - <b>Terrain mask</b> - renders mesh into Layer Map mask to control clutter placement (cubes) on landscape.</p>
				<p> - <b>Level terrain</b> - levels terrain height to the lowest point value within the polygon area.</p>
				<p> - <b>Lower terrain</b> - lowers terrain by 20 units within the polygon area.</p>
					]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
			<b>LMB</b> - Select object.<br/>
			<b>LMB (drag)</b> - Move object.<br/><br/>
			<b>F</b> - Focus on selected object.<br/>
			<b>U</b> or <b>ESC</b> - Deselect object.
			]]>
	</controls>
	<tags>
		<tag>Terrain</tag>
	</tags>
</sample>
<sample title="Usc Arrays" id="usc_arrays" category_id="unigine_script_interop">
	<sdk_desc><![CDATA[Integration between <i>C#</i> and <i>UnigineScript</i> by registering external <i>C#</i> functions that manipulate <i>UnigineScript</i> array types.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample showcases integration between <i>C#</i> and <i>UnigineScript</i> by registering external <i>C#</i> functions that manipulate <i>UnigineScript</i> array types.</p>
			<p>The registered functions allow for setting and getting values, generating test data, and enumerating the contents of both <i>ArrayVector</i> (indexed container) and <i>ArrayMap</i> (associative container).</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>UnigineScript</tag>
	</tags>
</sample>
<sample title="Usc Callbacks" id="usc_callbacks" category_id="unigine_script_interop">
	<sdk_desc><![CDATA[Calling <i>UnigineScript</i> functions from <i>C#</i> code via callbacks.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to call <i>UnigineScript</i> functions from <i>C#</i> code via callbacks.</p>
			<p>The mechanism is based on <i>Variable</i> Class instances and allows calling both custom and built-in script functions by name. The sample registers a <i>C#</i> wrapper function to expose script invocation capability to <i>UnigineScript</i> via the <i>Interpreter</i> class.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>UnigineScript</tag>
	</tags>
</sample>
<sample title="Usc Variables" id="usc_variables" category_id="unigine_script_interop">
	<sdk_desc><![CDATA[Working with different variable types in <i>UnigineScript</i> using the <i>Variable</i> class from <i>C#</i> code.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to work with different variable types in <i>UnigineScript</i> using the <i>Variable</i> class from <i>C#</i> code.</p>
			<p>Various types (<i>int, long, float, double</i>), and vector types (<i>vec3, vec4, dvec3</i>, etc.), are wrapped in <i>Variable</i> objects and passed into a <i>UnigineScript</i> callback function.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>UnigineScript</tag>
	</tags>
</sample>
<sample title="Object Frame" id="object_frame" category_id="user_interface">
	<sdk_desc><![CDATA[Using the <i>WidgetCanvas</i> class to render custom frames around objects in the viewport and save frame metadata as <i>JSON</i>.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample shows how to dynamically create and display rectangular frames around objects in the scene using the <i>WidgetCanvas</i>. These frames include object labels and appear only if the object is visible and is located within a certain distance from the camera.</p>
			<p>You can also take screenshots via the <i>Snap Screenshot</i> button. The captured image does not include the rendered frames, but all frame metadata (including object <i>ID</i>, name, transform, and screen coordinates of the frame) is saved to a separate <i>JSON</i> file. The screenshot and frame metadata are saved in the sample content folder.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Interface (GUI)</tag>
		<tag>Widgets</tag>
		<tag>File Formats</tag>
	</tags>
</sample>
<sample title="Object Text" id="object_text" category_id="user_interface">
	<sdk_desc><![CDATA[Demonstration of 3D text objects with adjustable parameters, animated colors, and rich formatting using the ObjectText class.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to create and control text objects in the scene via API, using the <i>ObjectText</i> class.</p>
			<p>It showcases different text rendering features, including adjustable font parameters, color animation, and support for rich text formatting:</p>
			<p><b>Left object</b> - a static <i>rich text</i> block with varying colors, font sizes, and outlines.</p>
			<p><b>Center object</b> - a user-editable text that can be customized through the Parameters window. It supports adjustments for wrap width, depth test, outline, vertical and horizontal spacing, font resolution, size, and rich text mode.</p>
			<p><b>Right object</b> - a dynamic text object that continuously updates its color over time, displaying its current RGBA values in real time.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Interface (GUI)</tag>
		<tag>Widgets</tag>
	</tags>
</sample>
<sample title="Target Marker" id="target_marker" category_id="user_interface">
	<sdk_desc>
		<![CDATA[Implementation of a marker that always highlights the target when it is within the field of view, or displays an arrow pointing the direction to the target when it is out of sight (aligned with the screen borders).]]>
	</sdk_desc>
	<desc>
		<brief>
		<![CDATA[Implementation of a marker that always highlights the target when it is within the field of view, or displays an arrow pointing the direction to the target when it is out of sight (aligned with the screen borders).]]>
		</brief>
	</desc>
	<tags>
		<tag>Interface (GUI)</tag>
		<tag>Game</tag>
		<tag>Basic Recipes</tag>
	</tags>
</sample>
<sample title="User Interface" id="user_interface" category_id="user_interface">
	<sdk_desc><![CDATA[On-the-fly generation of a user interface from a <b>.ui</b> file and setting event handlers for widgets.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[This sample shows how to generate a User Interface from a description stored in a <b>.ui</b> file (<i>XML</i> format) via C# API. The sample also demonstrates how to get a UI widget by name via <i>GetWidgetByName()</i> and subscribe to events to implement custom handling for user actions (particularly selecting <i>File -&gt; Reload</i> from the main menu or entering text in the text field on the <b>EditText</b> tab).]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
		Clicking an element allows you to interact with it.
		]]>
	</controls>
	<tags>
		<tag>Interface (GUI)</tag>
		<tag>Widgets</tag>
	</tags>
</sample>
<sample title="Widgets" id="widgets" category_id="user_interface">
	<sdk_desc><![CDATA[Implementation of various UI widgets in UNIGINE, such as sliders, scrolls, buttons, checkboxes, drop-down lists, etc.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates the implementation of various UI widgets in UNIGINE. It showcases how to create, configure and manage interactive <b>GUI</b> elements.</p>
			<p>The sample includes multiple widget types with event handling capabilities, demonstrating how to create and position widgets, configure visual properties, handle user interactions, etc., such as <b>sliders, scrolls, buttons, checkboxes, drop-down lists, etc.</b></p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Widgets</tag>
		<tag>Interface (GUI)</tag>
	</tags>
</sample>
<sample title="Widget Canvas" id="widget_canvas" category_id="user_interface">
	<sdk_desc><![CDATA[Using the <i>WidgetCanvas</i> class to draw vector-based shapes and text. The canvas supports adding lines, polygons, and text by defining their geometry through vertex positions. Elements are layered by draw order and colored individually.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to use the <i>WidgetCanvas</i> class to draw vector-based shapes and text. The canvas supports adding lines, polygons, and text by defining their geometry through vertex positions. Elements are layered by draw order and colored individually.</p>
			<p>The canvas content remains sharp regardless of scaling or rotation. In this example, the entire canvas is transformed over time, rotating and moving in 3D space while preserving the clarity of its contents. The geometry is built using helper functions that generate radial lines and regular polygons, and the layout is updated every frame using a transformation matrix.</p>
			<p>This can be used to create clean, scalable UI elements, procedural charts, custom overlays, or dynamic data visualizations in tools or applications.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Widgets</tag>
		<tag>Interface (GUI)</tag>
	</tags>
</sample>
<sample title="Widget Containers" id="widget_containers" category_id="user_interface">
	<sdk_desc>
		<![CDATA[Demonstration of various types of widget containers (vertical and horizontal box layouts, paned widgets, tabbed interfaces, group boxes, grid-based container, etc.) you can use when creating a User Interface.]]>
	</sdk_desc>
	<desc>
		<brief>
		<![CDATA[Demonstration of various types of widget containers (vertical and horizontal box layouts, paned widgets, tabbed interfaces, group boxes, grid-based container, etc.) you can use when creating a User Interface.]]>
		</brief>
	</desc>
	<tags>
		<tag>Widgets</tag>
		<tag>Interface (GUI)</tag>
	</tags>
</sample>
<sample title="Widget Dialog" id="widget_dialog" category_id="user_interface">
	<sdk_desc><![CDATA[Creating widget dialog windows and assigning handlers via the C# API.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to create and manage a GUI dialog system using UNIGINE's dialog widgets via the C# API. A <i>WidgetWindow</i> instance contains several buttons, each opening a different type of dialog: <i>WidgetDialogMessage</i>, <i>WidgetDialogFile</i>, <i>WidgetDialogColor</i>, or <i>WidgetDialogImage</i>.</p>
			<p>Each button is connected to an event handler that creates and configures the corresponding dialog widget. Dialogs are shown centered on screen and support user interaction through <i>OK</i> and <i>Cancel</i> buttons. A shared handler manages these responses, logs actions to the console, and deletes the dialog afterward to clean up resources.</p>
			<p>This approach can be used to build simple and interactive GUI tools, settings panels, or development utilities that require built-in dialog interactions.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Widgets</tag>
		<tag>Windows &amp; Viewports</tag>
		<tag>Interface (GUI)</tag>
	</tags>
</sample>
<sample title="Widget Manipulators" id="widget_manipulators" category_id="user_interface">
	<sdk_desc>
		<![CDATA[This sample demonstrates the use of manipulators. You can lock axes for transformations, and apply transformation in local or world coordinates.]]>
	</sdk_desc>
	<desc>
		<brief>
		<![CDATA[This sample demonstrates the use of manipulators. You can lock axes for transformations, and apply transformation in local or world coordinates.]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
		<b>LMB</b> - Select object.<br/>
		<b>W</b> - Move object mode.<br/>
		<b>E</b> - Rotate object mode.<br/>
		<b>R</b> - Scale object mode.<br/>
		<b>U</b>/<b>Esc</b> - Deselect object.<br/>
		<b>F</b> - Focus on selected object.
		]]>
	</controls>
	<tags>
		<tag>Interface (GUI)</tag>
		<tag>Widgets</tag>
	</tags>
</sample>
<sample title="Widget Window" id="widget_window" category_id="user_interface">
	<sdk_desc><![CDATA[Creating a basic <i>WidgetWindow</i> using the C# API and handling user interactions (edit line and button press events) through handler function connections.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to create a basic <i>WidgetWindow</i> using the C# API and handle user interactions (edit line and button press events) through handler function connections.</p>
			<p>This approach is suitable for building interactive UI elements directly within UNIGINE's native GUI system.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Widgets</tag>
		<tag>Interface (GUI)</tag>
		<tag>Windows &amp; Viewports</tag>
	</tags>
</sample>
</samples>
</samples_pack>
</meta>