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.22</version>
		<dependency>2.22</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>
		<git_repo>https://github.com/unigine-engine/csharp-component-samples/tree/release-2.22/source</git_repo>
		<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[			<p>This sample demonstrates additive blending of two animations in an <i>animation graph</i>.</p>
			<p>Unlike ordinary blending, where two animations are mixed and each of them gets only a part of the result, additive blending takes the difference between an animation and its reference pose and adds it on top of the base one. The base animation keeps playing in full, while the additive one only modifies it.</p>
			<p>Use the <i>Weight</i> slider in the sample window to change how much of the additive animation is applied. The slider sets a parameter of the graph, where the animations and the blending are configured.</p>
			<p>Additive blending is a technique for combining skeletal model animations, enabling smooth transitions and the seamless merging of character or object movements.</p>
		]]>
		</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[			<p>This sample demonstrates partial blending between two animations in an <i>animation graph</i>, where only the selected bones are affected.</p>
			<p>Two animations are played at the same time: the character keeps walking while the punching animation is blended into the upper part of the body only. The set of bones that receive the blended pose is defined by a mask assigned to the blending node of the graph.</p>
			<p>Use the <i>Weight</i> slider in the sample window to change how much of the punching animation is applied to the masked bones. The slider sets a parameter of the graph, where the animations, the blending, and the mask are configured.</p>
			<p>Partial blending lets a character perform different actions with different parts of its body at the same time, without preparing a separate animation for every combination.</p>
		]]>
		</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[			<p>This sample demonstrates linear interpolation between two animations in an <i>animation graph</i>.</p>
			<p>Two animations are played at the same time, and the poses they produce are mixed into the resulting one. The closer the weight is to either end, the more of the corresponding animation is left in the result, so the character goes from standing still to walking and back.</p>
			<p>Use the <i>Weight</i> slider in the sample window to change the proportion. The slider sets a parameter of the graph, where the animations and the blending are configured.</p>
			<p>Interpolating skeletal animations allows you to create smooth and natural transitions between different character or object movements.</p>
		]]>
		</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[Blending skeletal animations in an animation graph and rotating a bone programmatically.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to combine skeletal animation playback with direct modification of bone transforms.</p>
			<p>The turret plays an idle animation, over which the left and right shooting animations are blended additively by a state machine in the <i>animation graph</i>.</p>
			<p>On top of that, the horizontal joint of the turret is rotated from code at a constant speed. The rotation is applied after the animation graph has written its pose, so that the played animation does not overwrite it.</p>
			<p>Combining played animations with programmatic bone control is useful for turrets and other cases where part of a skeleton has to be driven by code rather than by a pre-made animation.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Animation</tag>
	</tags>
</sample>
<sample title="Animation Layers Playback" id="animation_layers_playback" category_id="animation_generic">
	<sdk_desc><![CDATA[Demonstration of animation sequences played in order or simultaneously.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates composing a single animation out of several reusable sequences using <i>AnimationChannelSubSequence</i> - a channel that holds other sequences as clips, with each clip having its own start time and duration.</p>
			<br/>
			<p>Three single-parameter sequences are created first: a Z position bounce, a rotation around the Z axis, and a scale pulse. They are then combined in two different ways, and both results are played at the same time:</p>
							<p> - The <b>left box</b> plays the clips starting at the same time, so its position, rotation, and scale are animated simultaneously.</p>
				<p> - The <b>right box</b> plays the clips one after another. A clip that has finished stops writing its parameter, and the box keeps the value it was left with.</p>
						<p>Both players use the same three sequences. Instead of duplicating them for each box, every player enumerates the binds of its sequences, including the ones inside the clips, and points them at its own box, so the sequences remain reusable and are not changed themselves.</p>
		]]>
		</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 transformations and material parameters using <i>Curve2D</i> for flexible, non-linear motion.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates animating node transformations and material parameters with <i>Curve2D</i> values sampled every frame.</p>
			<br/>
			<p>Two components are shown:</p>
							<p> - <b>CurveAnimationTransform</b> - animates the transformation of a node. Position, rotation, and scale have a separate curve for each of the <b>X, Y, Z</b> axes, so every axis can be shaped independently. The curves are evaluated at the current time and composed into the final transformation matrix. In the sample it moves the platforms, and changes the coins and heart transformations.</p>
				<p> - <b>CurveAnimationMaterialParamFloat</b> - animates float parameters of a material. Each entry of the list binds a curve to a parameter by its name and surface index, so any number of parameters can be animated at once. In the sample it pulses the emission of the coins and the heart.</p>
						<p>The curves and the playback speed are available in the properties of the corresponding component in UnigineEditor, where the curves can also be shaped in the <i>Curve Editor</i>.</p>
			<p>This setup is useful for looping motions and dynamic material effects that do not require external animation assets.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Animation</tag>
		<tag>Basic Recipes</tag>
		<tag>Transformations</tag>
	</tags>
</sample>
<sample title="Global Engine Parameters Animation" id="global_engine_parameters_animation" category_id="animation_generic">
	<sdk_desc><![CDATA[Animating global Engine parameters, such as physics gravity and render background color, using <i>singleton channels</i>.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates animating global Engine parameters using <b>singleton channels</b> - animation channels that have no bind and target a global system instead of a certain node, material, or property.</p>
			<p>Two parameters are animated at the same time by a single <i>AnimationSequence</i>: the Z component of physics gravity and the alpha component of the render background color. Their current values are displayed in the <i>State</i> window.</p>
			<p>The sequence is saved to a <b>.seq</b> file in the <b>sequences</b> folder of the world and then played back right from this file, demonstrating a serialization roundtrip. If the file is unavailable, the sequence stored in memory is played instead.</p>
			<p>Animating global parameters gives you programmatic control over scene effects, weather changes, time transitions, and physical properties, resulting in more engaging and interactive scenes.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Animation</tag>
		<tag>Basic Recipes</tag>
	</tags>
</sample>
<sample title="Material Parameters Animation" id="material_parameters_animation" category_id="animation_generic">
	<sdk_desc><![CDATA[Changing material parameters at runtime.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample illustrates how to change the parameters of <i>materials</i> at runtime. Each object in the scene has its own component that animates one of the parameters continuously:</p>
							<p> - <b>Albedo color</b> - smoothly transitions between two colors.</p>
				<p> - <b>Albedo texture</b> - alternates between two textures loaded from files.</p>
				<p> - <b>Metalness</b> - smoothly transitions between two values.</p>
				<p> - <b>Emission</b> state - is switched on and off, making the object blink.</p>
				<p> - <b>Cast World Shadow</b> state - is switched on and off, making the shadow of the object appear and disappear.</p>
						<p>The parameters can be edited in the properties of the corresponding components in UnigineEditor. The current value of every animated parameter is displayed in the <i>State</i> window.</p>
			<p>Changing material parameters at runtime is the basis for various dynamic effects, such as highlighting the objects the user interacts with, indicating the state of a device, or reproducing the changes of a surface over time.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Animation</tag>
		<tag>Materials</tag>
	</tags>
</sample>
<sample title="Node Parameters Animation" id="node_parameters_animation" category_id="animation_generic">
	<sdk_desc><![CDATA[Animating position, rotation, and scale of a node using <b>node binds</b> and different types of animation channels.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates animating the transformation of a node using <b>node binds</b> - <i>AnimationBindNode</i> objects that point animation channels at a certain node, identified by its ID and name.</p>
			<p>A box is animated by three channels of different types added to a single <i>AnimationSequence</i>, all of them sharing the same bind:</p>
							<p> - <i>AnimationChannelScalar</i> - animates a single float value, here the Z position of the box.</p>
				<p> - <i>AnimationChannelQuat</i> - animates rotation via quaternion interpolation. Along with the quaternion mode used here, the rotation can also be composed of three separate curves for each of the angles.</p>
				<p> - <i>AnimationChannelFVec3</i> - animates a three-component vector, here the scale of the box.</p>
						<p>The position channel gets its keyframes from an <i>AnimationCurveScalar</i> curve created explicitly, while the other two channels take the values directly. The keys use smooth interpolation based on a Bezier curve, so the box moves and resizes with easing instead of linearly.</p>
			<p>The current values of the animated parameters are displayed in the <i>State</i> window.</p>
			<p>Node animations can serve as a foundation for various effects, including element appearance/disappearance, rotations, resizing, and more.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Animation</tag>
	</tags>
</sample>
<sample title="Physics-Based Animation" id="physics_based_animation" category_id="animation_generic">
	<sdk_desc><![CDATA[Physics-based animation of movements using easing functions and spring simulation.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates several ways of moving an object towards a target smoothly, shown as a simple game.</p>
			<p>The sample has two modes, switched with the buttons in the description window.</p>
			<p>In the <b>Animations Demo</b> mode, the way of moving is selected from the drop-down list, with each of them implemented as a separate component:</p>
							<p> - <b>Linear</b> - moves at a constant speed.</p>
				<p> - <b>EaseIn</b> - accelerates gradually.</p>
				<p> - <b>EaseInOut</b> - accelerates at the start and decelerates at the end.</p>
				<p> - <b>EaseOut</b> - decelerates gradually.</p>
				<p> - <b>EaseOutElastic</b> - oscillates around the destination before settling on it.</p>
				<p> - <b>EaseOutBack</b> - overshoots the destination slightly and comes back to it.</p>
				<p> - <b>EaseOutBounce</b> - bounces at the destination.</p>
						<p>In the <b>Start Game</b> mode, you control the laser pointer with the mouse, and the cat chases it using spring simulation, becoming faster and more responsive over time until it catches the pointer.</p>
			<p>The parameters of each way of moving are available in the properties of the corresponding component in UnigineEditor.</p>
			<p>Easing and spring-based motion make the movement of objects look natural, which is useful for cameras, UI elements, followers, and any object that has to reach a moving target smoothly.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Animation</tag>
	</tags>
</sample>
<sample title="Property Animation" id="property_animation" category_id="animation_generic">
	<sdk_desc><![CDATA[Animating a parameter of a property assigned to a node and using the animated value to drive the logic of the sample.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates animating property parameters using <i>AnimationBindPropertyParameter</i>, which points an animation channel at a certain parameter of a property assigned to a node.</p>
			<p>A box has the <b>speed_prop</b> property assigned to it, with a single float parameter named <b>speed</b>. This parameter is animated by an <i>AnimationChannelFloat</i> channel: the value grows from 0 to 120, then goes down to -120, and returns back to 0.</p>
			<p>The animation itself does not move the box. Each frame the sample reads the current value of the <b>speed</b> parameter and rotates the box at this speed. The current value is displayed in the <i>State</i> window.</p>
			<p>This pattern is useful for data-driven animations, where the animation system controls the values, and the logic decides how to use them. The same animated parameter can be read by any number of components, and the property can be reassigned to another node without changing the animation.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Animation</tag>
		<tag>Properties</tag>
	</tags>
</sample>
<sample title="Track Playback" img="yes" id="track_playback" category_id="animation_generic">
	<sdk_desc><![CDATA[Using <i>Tracker</i> to animate the position, rotation, and scale of an object.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates playing back animation tracks created in the <b>Tracker</b> tool and stored in <b>.track</b> files.</p>
			<br/>
			<p>Three tracks are played at the same time, animating the position, rotation, and scale of the object independently. The position and rotation tracks are listed in the properties of the <b>Tracker</b> component and loaded on its initialization, while the scale track is added later by the <b>TrackPlayback</b> component.</p>
			<p>The tracks are addressed in two different ways: by their ID, cached once at initialization, and by their name, which is more readable but requires a lookup on every call.</p>
			<p>Each track keeps its own playback time, advanced every frame and wrapped back to the beginning at the end of the track.</p>
			<p>Tracker comes in handy for creating complex animation scenarios, where the animation is authored visually rather than in code.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Animation</tag>
	</tags>
</sample>
<sample title="Widget Animation" id="widget_animation" category_id="animation_generic">
	<sdk_desc><![CDATA[Animating widget position, font size, and color using runtime binds.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates animating widgets using <i>AnimationBindRuntime</i>, a bind that stores the runtime instance of a target object. It can point an animation channel at any Engine object, such as a widget, a body, or a camera.</p>
			<p>A looped title animation is played on three labels: the <b>Player 0</b> and <b>Player 1</b> labels are animated by position, font color, and font size, while the <b>vs</b> label between them is animated by font color only.</p>
			<p>A channel animates a single parameter, so a label animated by several parameters at once needs a separate channel for each of them, with the same bind assigned to all of them.</p>
			<p>Animating interface elements programmatically helps create more lively, appealing user interfaces and enables automation of their behavior.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Animation</tag>
		<tag>Interface (GUI)</tag>
		<tag>Widgets</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[			<p>This sample demonstrates advanced usage of the UNIGINE <b>event system</b>.</p>
			<p><i>EventsAdvancedSample.cs</i> triggers custom rotation events when specific keys are pressed. Each event passes one or more arguments to connected listeners.</p>
			<p><i>EventsAdvancedUnit.cs</i> shows how to connect various types of handlers, including:</p>
							<p> - Class methods with extra arguments</p>
				<p> - Methods with discarded or additional arguments</p>
				<p> - Delegates and lambda expressions</p>
				<p> - Storing connections using <i>EventConnection</i> or an <i>EventConnections</i> instance for later disconnection</p>
						<p>This sample helps understand flexible patterns for event handling in modular component systems.</p>
		]]>
		</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>
		<tag>Events</tag>
		<tag>Input &amp; Controls</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>
			<p><b>Core Features:</b></p>
							<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>
						<p><b>Use Cases:</b></p>
									<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[Composing and decomposing object rotation using Euler angles in different axis sequences.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how the order in which Euler angles are applied changes the resulting rotation. The same three angles applied as <i>XYZ, XZY, YXZ, YZX, ZXY</i>, or <i>ZYX</i> produce six different orientations.</p>
			<p>The sample also does the opposite: it takes the current rotation of the object and converts it back into <b>Pitch, Roll</b>, and <b>Yaw</b> angles for the selected sequence, displaying them as you rotate the object. These angles may differ from the ones used to set the rotation because of gimbal lock.</p>
			<p>The local axes of the object, the global axes, and a gimbal ring for each rotation step are drawn with the <i>Visualizer</i>, so every stage of the sequence is visible.</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. 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. 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>
		]]>
		</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[			<p>This sample demonstrates the importance of using <i>Game.IFps</i> to implement movement logic independent of the frame rate.</p>
			<p>Two cubes move back and forth along the X-axis. Use the <i>Max render fps</i> slider to change the frame rate of the application and compare their behavior.</p>
			<p>The green cube uses <i>Game.IFps</i> to scale its movement by the frame time delta, which keeps its speed consistent across varying frame rates.</p>
			<p>The red cube does not use <i>Game.IFps</i> and simply applies constant translation per frame, so its speed changes together with the frame rate.</p>
		]]>
		</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 <b>touchscreen</b>, 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>.]]>
	</sdk_desc>
	<desc>
		<brief>
		<![CDATA[This sample demonstrates how to add multi-touch input from the <b>touchscreen</b>, 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>File System</tag>
		<tag>Multithreading</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>File System</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[			<p>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.</p>
			<p>Profiling is crucial for identifying performance bottlenecks and optimizing code execution. This analysis helps you understand if any code sections negatively impact the project's speed.</p>
		]]>
		</brief>
	</desc>
	<exec>microprofile_enabled 1</exec>
	<edit>microprofile_enabled 1</edit>
	<tags>
		<tag>Optimization</tag>
		<tag>Profiling</tag>
	</tags>
</sample>
<sample title="Experimental Navigation Mesh" id="experimental_navigation_mesh" category_id="navigation">
	<sdk_desc><![CDATA[Configuring pathfinding between two points around obstacles using <b>Experimental Navigation Mesh</b>.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to configure pathfinding between two points with obstacles using <b>Experimental Navigation Mesh</b>. The route is built for an agent of a certain size, so a path is only found where the agent actually fits: it keeps clear of walls and obstacles, avoids slopes too steep to walk up and steps too high to climb, and gives up when the way around becomes too long. The resulting route is reported with its length, cost, and number of points, and if the target cannot be reached, the path is drawn up to the last point the agent can get to, with the reason explained. </p>
			<p>This sample is useful for pathfinding in games, for route checks in training simulators and digital twins, and for verifying that a building model stays passable for a given size.</p>
		]]>
		</brief>
	</desc>
	<link_docs>https://developer.unigine.com/docs/objects/navigations/experimental/index?rlang=cs</link_docs>
	<controls>
		<![CDATA[
		<p>Move the path endpoints and obstacles in the scene with the <b>widget manipulator</b>.<br/>
		<b>LMB</b> click on object to show the manipulator.<br/>
		<b>W</b> - switch the manipulator to movement mode<br/>
		<b>E</b> - switch the manipulator to rotation mode<br/>
		<b>F</b> - focus the camera on the selected object<br/>
		<b>U</b>, <b>Esc</b> - deselect the object</p>
		]]>
	</controls>
	<tags>
		<tag>Navigation &amp; Pathfinding</tag>
	</tags>
</sample>
<sample title="Experimental Navigation Mesh Character" id="experimental_navigation_mesh_character" category_id="navigation">
	<sdk_desc><![CDATA[Moving an animated character over an <b>Experimental Navigation Mesh</b> with the root motion of the animation graph.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates an animated character walking to a target over an <b>Experimental Navigation Mesh</b>. The character's movement along the route is taken from the root motion of the locomotion animations.</p>
			<p>Drag the target material ball with the manipulator and the character replans their route and walks to the new place. The locomotion settings can be adjusted in the <i>Parameters</i> section.</p>
			<p>The <i>Status</i> block reports the route state, the current animation state, the velocity the character actually moves at, and the rate the walk animation is played at.</p>
			<p>This sample is useful for animated agents navigating a scene: characters in games, pedestrians in a simulation, any unit whose animation is expected to drive its movement.</p>
		]]>
		</brief>
	</desc>
	<link_docs>https://developer.unigine.com/docs/objects/navigations/experimental/index?rlang=cs</link_docs>
	<controls>
		<![CDATA[
		<p>Move the target node in the scene with the <b>widget manipulator</b>.<br/>
		<b>LMB</b> click on object to show the manipulator.<br/>
		<b>W</b> - switch the manipulator to movement mode<br/>
		<b>F</b> - focus the camera on the selected object<br/>
		<b>U</b>, <b>Esc</b> - deselect the object</p>
		]]>
	</controls>
	<tags>
		<tag>Navigation &amp; Pathfinding</tag>
	</tags>
</sample>
<sample title="Experimental Navigation Mesh Conversion" id="experimental_navigation_mesh_conversion" category_id="navigation">
	<sdk_desc><![CDATA[Converting navigation data between the classic <b>Navigation Mesh</b> and the <b>Experimental Navigation Mesh</b>.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how navigation data can be moved between the classic <b>Navigation Mesh</b> and the <b>Experimental Navigation Mesh</b>.</p>
			<p>Both are baked by the same experimental navigation baker from one shared set of settings over the same scene geometry, so the two results can be compared side by side. Their data, however, is kept in different formats: the classic node stores a polygon mesh in a <b>.mesh</b> file, the experimental one a tiled <b>.navmesh</b> asset. The sample converts the data of one node into the format of the other: the classic mesh can be converted into the experimental format and back in memory, or exported to a <b>.mesh</b> file.</p>
			<p>The experimental system bakes the walkable surface from the scene geometry instead of areas placed by hand, streams it in tiles for worlds too large to fit in memory, and supports area volumes with their own cost.</p>
			<p>This sample is useful when moving a project to the new navigation system: the navigation already prepared for the classic node can be carried over as it is, and the two systems can run side by side while the migration is in progress.</p>
		]]>
		</brief>
	</desc>
	<link_docs>https://developer.unigine.com/docs/objects/navigations/experimental/index?rlang=cs</link_docs>
	<controls>
		<![CDATA[
		<p>Move the navigation mesh nodes in the scene with the <b>widget manipulator</b>.<br/>
		<b>LMB</b> click on object to show the manipulator.<br/>
		<b>W</b> - switch the manipulator to movement mode<br/>
		<b>E</b> - switch the manipulator to rotation mode<br/>
		<b>F</b> - focus the camera on the selected object<br/>
		<b>U</b>, <b>Esc</b> - deselect the object</p>
		]]>
	</controls>
	<tags>
		<tag>Navigation &amp; Pathfinding</tag>
	</tags>
</sample>
<sample title="Experimental Navigation Mesh Crowd" id="experimental_navigation_mesh_crowd" category_id="navigation">
	<sdk_desc><![CDATA[Moving a crowd of agents over an <b>Experimental Navigation Mesh</b> with collision avoidance.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates a crowd of agents moving over an <b>Experimental Navigation Mesh</b>, each one planning its own route and steering around the others on the way. Before an agent moves, it evaluates its neighbors and adjusts its speed and direction to avoid a collision. The crowd starts with a hundred agents and can be restarted with ten to three hundred.</p>
			<p>The sample provides three navigation scenarios:</p>
							<p> - <b>Bottleneck</b> - two teams on the opposite sides of a wall swap places, each agent taking the shortest route through the gates</p>
				<p> - <b>Circle</b> - the agents are placed on a circle and head for its diametrically opposite point</p>
				<p> - <b>Wander</b> - the agents walk between random points of the mesh</p>
						<p>The <i>Status</i> block reports the current scenario, the number of agents, and how many goals they have reached. <i>Agents without a route</i> is a diagnostic counter: anything above zero means an agent was spawned off the mesh or cannot reach its target.</p>
			<p>This sample is useful for crowds of characters in games, for pedestrian and evacuation simulations, and for any scene where many units or vehicles share the same space.</p>
		]]>
		</brief>
	</desc>
	<link_docs>https://developer.unigine.com/docs/objects/navigations/experimental/index?rlang=cs</link_docs>
	<tags>
		<tag>Navigation &amp; Pathfinding</tag>
	</tags>
</sample>
<sample title="Experimental Navigation Mesh Demo" id="experimental_navigation_mesh_demo" category_id="navigation">
	<sdk_desc><![CDATA[Configuring pathfinding to multiple targets on a plane with obstacles using <b>Experimental Navigation Mesh</b>.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates several material balls collecting coins on a plane with obstacles, navigating around by means of an <b>Experimental Navigation Mesh</b>. Each ball looks for its own way to the coin and follows it, staying on the navigation mesh as it moves; once a coin is collected, the next one appears elsewhere. Every ball has its own tab, so they can be given different settings and compared while they move - the ball being edited is highlighted in the scene.</p>
			<p>This sample is useful for crowds and groups of units in games, and for simulations where many vehicles or machines move through the same space at once.</p>
		]]>
		</brief>
	</desc>
	<link_docs>https://developer.unigine.com/docs/objects/navigations/experimental/index?rlang=cs</link_docs>
	<controls>
		<![CDATA[
		<p>Move the targets and obstacles in the scene with the <b>widget manipulator</b>.<br/>
		<b>LMB</b> click on object to show the manipulator.<br/>
		<b>W</b> - switch the manipulator to movement mode<br/>
		<b>E</b> - switch the manipulator to rotation mode<br/>
		<b>F</b> - focus the camera on the selected object<br/>
		<b>U</b>, <b>Esc</b> - deselect the object</p>
		]]>
	</controls>
	<tags>
		<tag>Navigation &amp; Pathfinding</tag>
	</tags>
</sample>
<sample title="Experimental Navigation Mesh Queries" id="experimental_navigation_mesh_queries" category_id="navigation">
	<sdk_desc><![CDATA[Performing spatial queries on an <b>Experimental Navigation Mesh</b>: nearest and reachable points, random points, boundaries, and polygons in an area.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates the spatial queries an <b>Experimental Navigation Mesh</b> can answer about the walkable area, without building a full route.</p>
			<p>The central ball is the query point: drag it around the level and, depending on the selected mode, see the nearest walkable position, the places reachable from here within a given travel cost, where the walkable area ends, or the parts of the mesh that fall inside a box drawn around the point. Seven queries with adjustable parameters are available, switched with the <b>Query mode</b> selector.</p>
			<p>These queries are the building blocks behind common gameplay and simulation tasks: placing a unit on walkable ground, showing how far it can go in one turn, scattering spawn points over the level, and keeping an agent away from ledges.</p>
			<p>The <i>Status</i> block reports the state of the mesh (polygons, walkable area size, loaded tiles) and the numbers the current query returned.</p>
		]]>
		</brief>
	</desc>
	<link_docs>https://developer.unigine.com/docs/objects/navigations/experimental/index?rlang=cs</link_docs>
	<controls>
		<![CDATA[
		<p>Move the query points in the scene with the <b>widget manipulator</b>.<br/>
		<b>LMB</b> click on object to show the manipulator.<br/>
		<b>W</b> - switch the manipulator to movement mode<br/>
		<b>E</b> - switch the manipulator to rotation mode<br/>
		<b>F</b> - focus the camera on the selected object<br/>
		<b>U</b>, <b>Esc</b> - deselect the object</p>
		]]>
	</controls>
	<tags>
		<tag>Navigation &amp; Pathfinding</tag>
	</tags>
</sample>
<sample title="Experimental Navigation Mesh Terrain" id="experimental_navigation_mesh_terrain" category_id="navigation">
	<sdk_desc><![CDATA[Navigating a large terrain using two levels of detail: a coarse <b>Experimental Navigation Mesh</b> for the whole world and a detailed one streamed and baked around the agents at runtime.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to build a hierarchical navigation model on a large terrain, so the full detail is only kept around the agents, instead of being held in memory all at once. The world holds two <b>Experimental Navigation Mesh</b> nodes different in resolution: a coarse one, baked with a large cell size, covering the terrain entirely, and a detailed one with small cells whose tiles are continuously baked and streamed as the agents move.</p>
			<p><b>Right-click</b> a place on the terrain to send the group of animated characters there. Each agent plans the whole route on the coarse mesh first, then splits it into legs and walks every leg on the detailed mesh. Both meshes are coloured depending on the area each polygon belongs to, which defines its traversal cost.</p>
			<p>Spawn and move obstacles on the agents' way to cut the walkable area out of both meshes, and see how the affected tiles are rebaked and the agents route around the obstruction.</p>
			<p>The <i>Status</i> block reports the state of both meshes and the route of the lead agent leg by leg, along with the failure reason when a route cannot be built.</p>
			<p>This sample is useful for open worlds and large simulation sites where the layout changes at runtime and a single navigation mesh cannot cover the needed detail.</p>
		]]>
		</brief>
	</desc>
	<link_docs>https://developer.unigine.com/docs/objects/navigations/experimental/index?rlang=cs</link_docs>
	<controls>
		<![CDATA[
		<p><b>RMB</b> click on the terrain - send the agents to that point<br/>
		Move the spawned obstacles in the scene with the <b>widget manipulator</b>.<br/>
		<b>LMB</b> click on object to show the manipulator.<br/>
		<b>W</b> - switch the manipulator to movement mode<br/>
		<b>E</b> - switch the manipulator to rotation mode<br/>
		<b>F</b> - focus the camera on the selected object<br/>
		<b>U</b>, <b>Esc</b> - deselect the object</p>
		]]>
	</controls>
	<tags>
		<tag>Navigation &amp; Pathfinding</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>The <i>System.Net.Http.HttpClient</i> class is used to perform the <i>HTTP</i> requests. 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>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>Clicking</b> on an existing mesh removes it from the cluster.<br/><b>Clicking</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[Demonstration of how various parameters influence the accuracy of fetch and intersection operations on the <i>Global Water</i> 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>Logic</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 falling objects fracturing upon collision implemented 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 spawned every 3 seconds by default 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 <i>hinge</i> 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 physical behavior of joints under load.</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>Logic</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 implementation 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 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>Games</tag>
		<tag>Basic Recipes</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[Creating 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> parameter 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>Complex Solutions</tag>
		<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>Cameras</tag>
		<tag>Games</tag>
		<tag>Basic Recipes</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>Objects</tag>
		<tag>Procedural</tag>
		<tag>Optimization</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>Objects</tag>
		<tag>Procedural</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 the number of ready mesh objects along with the RAM and resident VRAM taken by their mesh data (queried per object via the <i>MeshRender</i> memory usage methods). 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>Procedural</tag>
		<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="Sensor Zone Visualizer" id="sensor_zone_visualizer" category_id="procedural_generation_placement">
	<sdk_desc><![CDATA[Procedural frustum mesh generator for visualizing sensor fields of view with live controls for angles, distance, and color.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates procedural generation of frustum meshes for visualizing sensor fields of view. Four frustums are placed on a single object, facing <i>forward</i>, <i>back</i>, <i>left</i> and <i>right</i>. Each frustum is built as a spherical sector (not a real frustum) with adjustable parameters:</p>
							<p> - <b>Near/Far distance</b> - radial distances of the spherical caps</p>
				<p> - <b>Left/Right frustum border</b> - horizontal angle range</p>
				<p> - <b>Lower/Upper frustum border</b> - vertical angle range</p>
				<p> - <b>Color</b> - color of the frustum mesh.</p>
						<p>Move the sliders to rebuild the selected frustum's mesh dynamically.</p>
			<p>Fields of view greater than 180 degrees are supported, so the frustums can visualize sensors ranging from a narrow-angle camera to a hemispherical fisheye.</p> 		]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
		<p><b>W,A,S,D</b> - Camera movement</p>
		<p><b>RMB</b> - Camera rotation</p>
		]]>
	</controls>
	<tags>
		<tag>Objects</tag>
		<tag>Visualizer (Visual Debug)</tag>
	</tags>
	<keywords>Sensor Zone,Spherical Sector,Procedural,Mesh,FOV</keywords>
</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>Render</tag>
	</tags>
</sample>
<sample title="Gui To Texture" id="gui_to_texture" category_id="rendering">
	<sdk_desc><![CDATA[Rendering GUI elements into a texture using <i>Gui.Render()</i> and applying the resulting texture to materials.]]></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 <b>Manual</b> mode, the texture is updated only when explicitly calling the <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> - <b>Automatic</b> 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>RMB</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 compositing it over the main scene.</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>
			<p>The setup uses two cameras with identical transforms to keep their views aligned. <i>Viewport masks</i> for cameras are set via UnigineEditor: the main camera renders everything except the weapon, while the secondary (weapon) camera renders only the weapon. The weapon view is captured into a texture using <i>Viewport.RenderTexture2D()</i>.</p>
			<p>Each frame, this texture is overlaid onto the screen using <i>Render.RenderScreenMaterial()</i>, compositing the weapon on top of the environment. The component handles screen resizing, maintains isolated render states, and offers optional settings like skipping shadows in the weapon rendering pass.</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>
		<tag>Basics</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>
		<tag>Sim</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 <b>path visualization</b> on and off, adjust the planes' <b>velocity</b>, or <b>switch between the cameras</b> 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>Basic Recipes</tag>
		<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>Basic Recipes</tag>
		<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/></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, 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>
		<tag>Procedural</tag>
		<tag>World Management</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="Fonts" id="fonts" category_id="user_interface">
	<sdk_desc><![CDATA[Multi-script text rendering (English, Russian, Arabic, Thai, Chinese, Hindi) across GUI widgets, 3D <i>ObjectText</i>, and world-space <i>ObjectGui</i>, with configurable text direction, cursor mode, and font size.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates text display features in UNIGINE across six languages - English, Russian, Arabic, Thai, Chinese, and Hindi - including right-to-left and complex script support. The same text is rendered on GUI widgets, a 3D <i>ObjectText</i>, and a world-space <i>ObjectGui</i> nodes.</p>
			<p>The <b>Parameters</b> window allows you to control:</p>
							<p> - <b>Text direction</b> - Auto-detects direction per string (LTR/RTL force one direction for every widget at once).</p>
				<p> - <b>Cursor mode</b> - Defines how the caret steps through bidirectional text: <i>Auto, Visual</i>, or <i>Logical</i>. Works on GUI widgets in the <i>Multi-script font features</i> window.</p>
				<p> - <b>GUI Font size</b> - Applied dynamically to all GUI widgets in the <i>Multi-script font features</i> window.</p>
				<p> - <b>Show widget font features</b> - Toggles <b>Multi-script font features</b> demonstration window with various widget types and text features.</p>
						<p>For correct shaping of Arabic, Thai, and Hindi, the sample relies on a list of additional fonts set with <i>setGlobalFontFallback()</i>. The required Noto/Hind font files should be located in the <b>data/</b> folder. Missing fonts are rendered as placeholder boxes.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Interface (GUI)</tag>
		<tag>Widgets</tag>
	</tags>
</sample>
<sample title="Measurements" id="measurements" category_id="user_interface">
	<sdk_desc><![CDATA[Dynamically measuring and visualizing the distance from a movable node to surrounding target nodes.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample shows how to measure distances in a scene at runtime and display them as on-screen rulers.</p>
			<p>A set of target objects is placed around a single movable node. Every frame the distance from this node to each target is measured and drawn with the <i>Visualizer</i> as an arrow with a 3D label showing the length in meters. The arrows are clipped to object surfaces for precise surface-to-surface measurements. </p>
			<p>The ruler color transitions from red (near) to green (far), and a white zone circle is drawn around each target. Green distance threshold and zone radius are adjustable in the <b>Parameters</b> window.</p>
		]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
		<p><b>W, S</b> - Move the controlled node forward / backward</p>
		<p><b>A, D</b> - Turn the controlled node left / right</p>
		]]>
	</controls>
	<tags>
		<tag>Visualizer (Visual Debug)</tag>
		<tag>Transformations</tag>
	</tags>
	<keywords>Distance,Measurement,Visualizer,Ruler</keywords>
</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>Games</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, such as sliders, scrolls, buttons, checkboxes, drop-down lists and others.]]></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 and others</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>