cpp_component_samples.sample

<?xml version='1.0' encoding='UTF-8'?>
<meta>
	<samples_pack name="cpp_component_samples">
		<title>C++ 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 cpp_component_samples</command>
		<custom_app>cpp_component_samples</custom_app>
		<bin_type>development</bin_type>
		<api>cmakecpp,vs2015cpp</api>
		<plugins>FMOD,SpiderVision</plugins>
		<git_repo>https://github.com/unigine-engine/cpp-api-samples/tree/release-2.22/source</git_repo>
		<description>
			<![CDATA[
				<p>A set of samples showcasing the use of engine features for various use cases via the C++ API.</p>
			]]>
		</description>
		<features>
			<![CDATA[
				<p><strong>Intersections</strong> samples different cases of intersection detection. The following samples are available:</p>
				<ul>
					<li><strong>Simple Async Request</strong> sample - demonstrating detection of intersections with all objects in the world using a combination of <em>World::getIntersection()</em> and <em>Landscape::getIntersection()</em> methods. A single ray from the mouse cursor position is used. A normal at the point of intersection is rendered and latency value is displayed.</li>
					<li><strong>Multiple Async Requests</strong> sample - demonstrating detection of intersections with all objects in the world using a combination of <em>World::getIntersection()</em> and <em>Landscape::getIntersection()</em> methods. 900 rays from a moving emitter-objects are used. You can check out latency values (number of frames per each result).</li>
				</ul>
				<p><strong>Landscape Terrain</strong> samples demonstrating various Landscape Terrain features and use cases. The following samples are available:</p>
				<ul>
					<li><strong>Combined Landscape Modification</strong> sample - demonstrating combination of nondestructive (using multiple Landscape Layer Maps) and destructive (using <b>Landscape::asyncTextureDraw</b>) Landscape Terrain modification techniques.</li>
					<li><strong>Landscape Creation</strong> sample - demonstrating dynamic creation of a Landscape Layer Map with albedo, height, and two mask textures using <b>LandscapeMapFileCreator</b> and <b>LandscapeMapFileSettings</b>.</li>
					<li><strong>Details</strong> sample - demonstrating how to add Details to a Landscape Terrain using <b>ObjectLandscapeTerrain::getDetailMask</b> and <b>ObjectLandscapeTerrain::addDetail</b> methods.</li>
					<li><strong>Fetch</strong> sample - demonstrating how to get terrain information (height, albedo, masks) for an arbitrary point.</li>
					<li><strong>Landscape Mesh</strong> sample - demonstrating generation of a mesh (<b>ObjectMeshDynamic</b>) representing a certain region of the Landscape Terrain based on fetched Landscape data (<b>LandscapeFetch</b>).</li>
					<li><strong>Paint</strong> sample - demonstrating destructive run-time Landscape Terrain modification by changing the underlying textures of the Landscape Layer Map using <b>Landscape::asyncTextureDraw</b> with the help of the custom base materials.</li>
					<li><strong>Tracks</strong> sample - demonstrates non-destructive runtime Landscape Terrain modification by spawning multiple Landscape Layer Maps under the objects to create tracks.</li>
				</ul>
				<p><strong>Tracker</strong> sample demostrating how to use <b>Tracker</b> to animate objects (change their position, rotation, and scale) via tracks created in the <b>Tracker</b> tool. Tracks in code are referred to via names and IDs. A C++ wrapper for <b>Tracker</b> functionality is provided in the <b>Tracker</b> component.</p>
				<p><strong>Water Global</strong> samples demostrating how to control Global Water via API. The following samples are available:</p>
				<ul>
					<li><strong>Buoyancy</strong> sample - demonstrating the control over the current state of the Global Water via changing Beaufort levels (the Beaufort slider). It also demonstrates the use of fetching of the water level at a certain point for simplified simulation of buoyancy without engaging Phyiscs.</li>
					<li><strong>CustomWave</strong> sample - demonstrating how to control the wave spectrum of Global Water in Manual mode via API by changing the number of octaves, number of waves per octave, and various other parameters for random waves generation, such as wave length, amplitude, phase offset, and steepness (can be used, for example, to process Weather Control packets from IOS in a simulator application).</li>
					<li><strong>Boat</strong> sample - demonstrating how to simulate ship wake foam via <b>Orthographic Decals</b> and <b>Particle Systems</b>, that are spawned behind the boat and project foam onto the water surface. You can control sea state via the Beaufort slider (from 0 - calm to 8 - huge waves).</li>
					<li><strong>Fetch Intersection</strong> sample - demonstrating the influence of the <b>Steepness Quality, Amplitude Threshold</b>, and <b>Precision</b> parameters on the accuracy of fetch and intersection requests for the <b>Global Water</b> object at various Beaufort levels.</li>
				</ul>
				]]>
		</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/cpp_component_samples_rect.png</card_image>
			<thumb>.meta/images/cpp_component_samples_sm.png</thumb>
			<image>.meta/images/cpp_component_samples_001.png</image>
			<image>.meta/images/cpp_component_samples_002.png</image>
			<image>.meta/images/cpp_component_samples_003.png</image>
			<image>.meta/images/cpp_component_samples_004.png</image>
			<image>.meta/images/cpp_component_samples_005.png</image>
		</images>
		<copy_configuration>
			<dir tag="external_resources">external_resources</dir>
		</copy_configuration>
	<categories>
		<category id="scene_management" name="Scene Management" order="10" img="data/cpp_component_samples/scene_management/scene_management.png"/>
		<category id="player_controllers" name="Player Controllers" order="20" img="data/cpp_component_samples/player_controllers/player_controllers.png"/>
		<category id="input_handling" name="Input Handling" order="30" img="data/cpp_component_samples/input_handling/input_handling.png"/>
		<category id="app_logic" name="App Logic" order="40" img="data/cpp_component_samples/app_logic/app_logic.png"/>
		<category id="procedural_generation_placement" name="Procedural Generation &amp; Placement" order="50" img="data/cpp_component_samples/procedural_generation_placement/procedural_generation_placement.png"/>
		<category id="multi_threading_performance_optimization" name="Multithreading &amp; Performance Optimization" order="60" img="data/cpp_component_samples/multi_threading_performance_optimization/multi_threading_performance_optimization.png"/>
		<category id="simulation" name="Simulation" order="70" img="data/cpp_component_samples/simulation/simulation.png"/>
		<category id="nodes" name="Nodes" order="80" img="data/cpp_component_samples/nodes/nodes.png"/>
		<category id="terrain_modification_usage" name="Terrain Modification &amp; Usage" order="90" img="data/cpp_component_samples/terrain_modification_usage/terrain_modification_usage.png"/>
		<category id="physics" name="Physics" order="100" img="data/cpp_component_samples/physics/physics.png"/>
		<category id="rendering" name="Rendering" order="110" img="data/cpp_component_samples/rendering/rendering.png"/>
		<category id="animation_generic" name="Animation - Generic" order="120" img="data/cpp_component_samples/animation_generic/animation_generic.png"/>
		<category id="animation_characters" name="Animation - Characters" order="130" img="data/cpp_component_samples/animation_characters/animation_characters.png"/>
		<category id="navigation" name="Navigation" order="140" img="data/cpp_component_samples/navigation/navigation.png"/>
		<category id="user_interface" name="User Interface" order="150" img="data/cpp_component_samples/user_interface/user_interface.png"/>
		<category id="sounds" name="Sounds" order="160" img="data/cpp_component_samples/sounds/sounds.png"/>
		<category id="network" name="Network" order="170" img="data/cpp_component_samples/network/network.png"/>
		<category id="unigine_script_interop" name="UnigineScript Interop" order="180" img="data/cpp_component_samples/unigine_script_interop/unigine_script_interop.png"/>
	</categories>
<samples>
<sample title="Bones: Constraints [Animation Graph]" order="1" id="bones_constraints" category_id="animation_characters">
	<sdk_desc><![CDATA[Applying bone rotation constraints and observing how they affect inverse kinematics.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates the use of joint rotation limits in an <i>animation graph</i> and illustrates how they affect the operation of inverse kinematics.</p>
			<p>The target of the chain is moved with a manipulator, and the <i>IK Chain</i> node bends the bones of the left leg towards it. The rotation of each joint is limited, so the chain can only bend the way a real joint would, instead of taking any pose that reaches the target.</p>
			<p>Every joint has its own limit node, with the joint, the axes, and the angles set in its parameters. A <i>Joint Limit Set</i> node gathers them all into a single set that is applied to the chain.</p>
			<p>Rotation constraints are useful for keeping automatically generated poses plausible, for example, to prevent an elbow or a knee from bending backwards.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Animation</tag>
	</tags>
</sample>
<sample title="Bones: Foot Placement [Animation Graph]" order="1" id="bones_foot_placement" category_id="animation_characters">
	<sdk_desc><![CDATA[Adjusting the feet of a character to the height and the slope of an uneven surface using inverse kinematics and raycasting.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates a naive option for placing feet on a surface using inverse kinematics in an <i>animation graph</i>: a <i>Two Bone IK</i> node per leg bends them towards the points the feet have to reach, with the pelvis position adjusted so that both legs can reach the surface.</p>
			<p>Raycasting is applied to detect surface contact: in each frame, a ray is cast downward through the foot position to find intersections with the surface. The resulting contact point and surface normal are then used to adjust the foot bones' position and orientation, ensuring realistic foot placement. Both the rays and the normals found at the contact points are visualized on the character.</p>
			<p>Each leg blends into inverse kinematics only while its ray hits the surface, so a foot that steps off the platform returns to the animated pose smoothly instead of snapping.</p>
			<p>The platform under the character can be moved with the manipulator switched on by the <i>T</i> key and rotated with the one switched on by the <i>R</i> key, so you can watch the feet adapt to the changing height and slope in real time.</p>
		]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
		<p>Key <b>T</b> - Platform movement manipulator.</p>
		<p>Key <b>R</b> - Platform rotation manipulator.</p>
		]]>
	</controls>
	<tags>
		<tag>Animation</tag>
		<tag>Intersections</tag>
	</tags>
</sample>
<sample title="Bones: Inverse Kinematics [Animation Graph]" order="1" id="bones_inverse_kinematics" category_id="animation_characters">
	<sdk_desc><![CDATA[Controlling bones with inverse kinematics.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to control bones using inverse kinematics in an <i>animation graph</i>. Instead of rotating each bone individually, the <i>Two Bone IK</i> node takes the position the end of the chain has to reach and bends the bones towards it. Here the chain is the left leg of the character, with its three joints picked in the node's parameters.</p>
			<p>The node takes the pose from the <i>Animation Player</i> node, solves the chain against the target, and passes the result on, so the idle keeps playing while the foot reaches for it. The lower manipulator moves that target, the upper one moves the pole vector that defines the plane the chain bends in.</p>
			<p>The example is useful for creating animations where character bones are automatically positioned and oriented to achieve realistic movement.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Animation</tag>
	</tags>
</sample>
<sample title="Bones: Look At Chains [Animation Graph]" order="1" id="bones_look_at_chains" category_id="animation_characters">
	<sdk_desc><![CDATA[Using LookAt chains to aim the bones of a character at a target.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates the use of LookAt chains for aiming at a target in an <i>animation graph</i>: the <i>Look At Chain</i> node turns the bones of the chain automatically so that the character follows the target with its body.</p>
			<p>The chain contains three spine bones, the neck, and the head. Each of them has its own weight defining how much it contributes to the resulting rotation - the weights grow towards the head, so the head turns the most and the body follows more subtly.</p>
			<p>One manipulator moves the target the character looks at, the other one moves the pole vector that sets the upward direction for the bones of the chain.</p>
			<p>The bones, their weights, and their axes are set in the parameters of the <i>Look At Chain</i> node.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Animation</tag>
	</tags>
</sample>
<sample title="Bones: Retargeting [Animation Graph]" order="1" id="bones_retargeting" category_id="animation_characters">
	<sdk_desc><![CDATA[Using the same animation on skeletons with different proportions.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how the same animation can be used on skeletons with different proportions.</p>
			<p>Both pairs play the same walking animation through an <i>animation graph</i>. The pair on the left plays it as is, so the child inherits the proportions of the adult and appears stretched. The pair on the right plays the retargeted version, where the child keeps its own proportions.</p>
			<p>Retargeting works automatically as long as the skeleton is shared between the skinned mesh and the animation. To prevent stretching when the proportions differ, rotation-only masks are applied to most of the bones, while the hip and the ground-contact bones receive full transformations to keep the body height and the placement on the ground correct.</p>
			<p>Retargeting is useful when you need to use the same animation source for different characters or objects with varying proportions but similar skeletal structures. This approach significantly speeds up the process of preparing animations.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Animation</tag>
	</tags>
</sample>
<sample title="Bones: Root Motion [Animation Graph]" order="1" id="bones_root_motion" category_id="animation_characters">
	<sdk_desc><![CDATA[Moving an object by the offset of the root bone of its animation.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates the implementation of the <b>root motion</b> technique, where the movement stored in the root bone of an animation is applied to the object itself instead of being played in place.</p>
			<p>Both characters play the same walking animation through an <i>animation graph</i>, and the only difference between the two graphs is the <b>Root Motion</b> option. The character on the left keeps walking in place, while the one on the right is carried along the path of the animation. The coordinate axes drawn at the position of each character show the difference.</p>
			<p>The movement accumulated by the animation is read every frame as a delta transformation and applied to the world transformation of the node after the animation has been evaluated.</p>
			<p>Root motion is particularly valuable for realistic character, vehicle, or object movements in games and simulations, as the object goes exactly where the animation takes it, with no foot skating.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Animation</tag>
	</tags>
</sample>
<sample title="Bones: State Machine [Animation Graph]" order="1" id="bones_state_machine" category_id="animation_characters">
	<sdk_desc><![CDATA[Controlling character animation with state machines and blend spaces built in an animation graph.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to build animation state machines in an <i>animation graph</i>. A state machine manages various object states - such as idle, walking, or running - and handles transitions between them.</p>
			<br/>
			<p>Three characters show different configurations, each with its own graph:</p>
							<p> - <b>Walk</b> (left) - transitions between idle and walking depending on the speed value, with a separate turn-around animation triggered by a flag.</p>
				<p> - <b>Turn</b> (center) - a one-dimensional <i>blend space</i>, where a single value between -1 and 1 blends between turning left, standing still, and turning right.</p>
				<p> - <b>Run</b> (right) - a two-dimensional blend space, where one value blends idle, walking, and running, and the other one blends turning to the left and to the right.</p>
						<p>The component itself only sets the named parameters of each graph from the keyboard input, while all the states, transitions, and blending are configured in the graph assets. Every state machine also uses root motion, so the characters are carried by the animations they play.</p>
			<p>Implementing state machines enables the creation of complex, flexible character behaviors.</p>
		]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
		<p>Walk State Machine (left):</p>
		<p>    Key <b>T</b> - set maximum speed.</p>
		<p>    Key <b>G</b> - set minimum speed.</p>
		<p>    Key <b>Y</b> - turn around.</p>
		<p>    </p>
		<p>Idle Turn State Machine (center):</p>
		<p>    Key <b>V</b> - increase turn left.</p>
		<p>    Key <b>C</b> - increase turn right.</p>
		<p>    </p>
		<p>Walk Run State Machine (right):</p>
		<p>    Key <b>I</b> - increase y.</p>
		<p>    Key <b>K</b> - decrease y.</p>
		<p>    Key <b>L</b> - increase x.</p>
		<p>    Key <b>J</b> - decrease x.</p>
		]]>
	</controls>
	<tags>
		<tag>Animation</tag>
	</tags>
</sample>
<sample title="Bones: Masks" id="bones_masks" category_id="animation_characters">
	<sdk_desc><![CDATA[Using masks to assign selective logic to different bones.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to use bone masks to selectively apply animation data.</p>
			<p>Masks enable complex animation combinations. For example, you can preserve the original body movements while limiting head or arm animations to rotation, or scaling specific bones.</p>
			<p>In this example, the right (child) model has a component that lists bones using a rotation-only mask from the left (adult) model's animation. The scale is masked out, so the listed bones keep their original size. If the mask is not applied, the bones appear stretched, as all transformations (including scale) are copied from the adult model. This can be seen on the child model's arms, where the mask is not used.</p>
			<p>Masking is enabled per animation layer, and every bone listed in the properties of the sample component is then set to take the rotation from the animation only, leaving its own position and scale intact.</p>
			<p>This method is excellent for multi-layered animations, allowing you to mix motions, add effects, or exclude certain parts of the model to achieve specific visual results or behaviors without duplicating full animation sets.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Animation</tag>
	</tags>
</sample>
<sample title="Bones: Sandbox" id="bones_sandbox" category_id="animation_characters">
	<sdk_desc><![CDATA[An interactive sandbox for setting up IK chains, LookAt chains, and bone rotation constraints at runtime.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample provides the interface that allows visualizing and experiencing how to configure all available settings for IK chains, LookAt chains, and bone rotation constraints.</p>
			<p>The skeleton of the character is displayed as a tree, where you can pick the bone to work with and see it highlighted in the viewport. Three editors are available for it:</p>
							<p> - <b>IK</b> - creating chains and adjusting the target and pole positions, the rotation of the effector, the number of solver iterations, the tolerance, and the constraint modes.</p>
				<p> - <b>LookAt</b> - creating chains, adding bones to them, setting the target and pole positions, and adjusting the weight and the axes of each bone.</p>
				<p> - <b>Constraints</b> - setting the minimum and maximum angles of rotation around the yaw, pitch, and roll axes for a certain bone.</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>
			<p>Composing animations out of reusable pieces makes it possible to build complex animation scenarios from a small set of simple sequences and reuse them for any number of objects.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Animation</tag>
	</tags>
</sample>
<sample title="Curve2D Animation" id="curve2d_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 <i>node binds</i> 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 <b>0</b> to <b>120</b>, then goes down to <b>-120</b>, and returns back to <b>0</b>.</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="Tracker: Playback" id="tracker_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>
			<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.cpp</i> triggers custom rotation events when specific keys are pressed. Each event passes one or more arguments to connected listeners.</p>
			<p><i>EventsAdvancedUnit.cpp</i> shows how to connect various types of handlers, including:</p>
							<p> - Class methods with extra arguments</p>
				<p> - Free functions with discarded or additional arguments</p>
				<p> - Lambdas using <i>connectUnsafe()</i></p>
				<p> - Storing connections using <i>EventConnection</i> or <i>EventConnectionId</i> for later disconnection</p>
						<p>This sample helps understand flexible patterns for event handling in modular component systems.</p>
		]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
		<p><b>T</b> — Rotate around X-axis</p>
		<p><b>Y</b> — Rotate around Y-axis</p>
		<p><b>U</b> — Rotate around Z-axis</p>
		<p><b>I</b> — Rotate around all axes (XYZ)</p>
		]]>
	</controls>
	<tags>
		<tag>Systems</tag>
		<tag>Logic</tag>
		<tag>Events</tag>
		<tag>Input &amp; Controls</tag>
	</tags>
	<keywords>Input,Keyboard,Subscription</keywords>
</sample>
<sample title="Component Parameters In Editor" 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="Component System Example" id="component_system_example" category_id="app_logic">
	<sdk_desc><![CDATA[Demonstration of UNIGINE's C++ component-based architecture using custom gameplay components with dynamic object creation and interaction.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample illustrates how to implement your application's logic via a set of building blocks - <b>components</b>, and assign these blocks to nodes. A logic component integrates a node, a property, and a C++ class containing logic implementation.</p>
			<p>The sample includes a controllable pawn with basic movement, rotating boxes that periodically spawn projectiles, and a floating UI label displaying health, survival time, and active component count.</p>
			<p>The sample demonstrates how to:</p>
							<p> - Decompose application logic into modular, reusable components</p>
				<p> - Create and assign custom logic components at runtime</p>
				<p> - Implement interaction between independently managed components.</p>
						<p>More details about the Component System sample are available in the official documentation linked below.</p>
		]]>
		</brief>
	</desc>
	<link_docs>https://developer.unigine.com/docs/code/usage/using_component_system/index?rlang=cpp</link_docs>
	<controls>
		<![CDATA[<p align=left>Keys <b>UP / W</b> and <b>DOWN / S</b> to move forward/backward</p>
		<p align=left>Keys <b>LEFT / A</b> and <b>RIGHT / D</b> for clockwise/counterclockwise rotation</p>
		]]>
	</controls>
	<tags>
		<tag>Logic</tag>
		<tag>Basic Recipes</tag>
		<tag>Component System</tag>
	</tags>
	<keywords>Architecture,Game</keywords>
</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="Custom Stream" id="custom_stream" category_id="app_logic">
	<sdk_desc><![CDATA[Creating a custom stream class by inheriting from <i>StreamBase</i> and using it for reading from and writing to files.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to create a custom stream class by inheriting from <i>StreamBase</i> and use it for reading from and writing to files. The resulting stream is used to serialize and deserialize basic data types to and from a binary file.</p>
			<p>The sample provides a wrapper around standard <i>C</i> file <i>I/O</i> functions and integrates with the <b>UNIGINE</b> stream system by implementing the <i>StreamBase</i> interface. In the sample logic, a binary file is first created and filled with data via <i>Stream::writeString()</i>, <i>writeInt()</i>, and <i>writeFloat()</i>. Then the file is reopened in read mode and the same values are read back using the corresponding <i>Stream 'read'</i> methods, verifying the functionality of the custom stream.</p>
			<p>This example serves as a reference for implementing custom stream sources (e.g., from memory, network, or virtual filesystems) and integrating them with the Engine's serialization tools.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<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>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Basic Recipes</tag>
		<tag>Transformations</tag>
	</tags>
	<keywords>Math</keywords>
</sample>
<sample title="Event Connection Patterns" id="event_connection_patterns" category_id="app_logic">
	<sdk_desc><![CDATA[Demonstration of four different patterns of subscribing to UNIGINE's <i>Events</i> via the C++ API, highlighting how event handler lifetime and management can vary depending on the approach.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates four different patterns for subscribing UNIGINE's <i>Events</i> via the C++ API, highlighting how event handler lifetime and management can vary depending on the approach.</p>
			<p>Each method demonstrates a different strategy for connecting to the same event and managing event handler lifetimes:</p>
							<p> - <i>EventConnectionExample</i> stores a single event handler with manual control over its activation. This type of connection is useful when you need precise control &#8212; you can enable, disable, or fully disconnect the handler at any time.</p>
				<p> - <i>EventConnectionsExample</i> acts as a container for multiple handlers. It handles cleanup automatically (via the destructor) and manually (by calling <i>EventConnections::disconnectAll()</i>). This is useful when you have many event handlers with varying lifetimes that need to be grouped.</p>
				<p> - <i>InheritedEventConnectionExample</i> inherits <i>EventConnections</i> class, making connection management part of its internal logic. All connected handlers are automatically disconnected when the object is destroyed.</p>
				<p> - <i>CallbackIDConnection</i> provides a low-level, manual way to manage handlers using a connection ID. It offers flexibility but requires careful memory and lifetime handling. This approach is considered unsafe and should only be used when you fully understand the implications.</p>
						<p>Each example connects to a shared <i>EventHolder</i>, and handlers are triggered with a sample value. This setup is useful when designing modular, reactive systems that rely on flexible and explicit event-driven logic.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Systems</tag>
		<tag>Logic</tag>
		<tag>Events</tag>
	</tags>
	<keywords>Subscription</keywords>
</sample>
<sample title="File System 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="File System Mount Points" id="filesystem_mount_points" category_id="app_logic">
	<sdk_desc><![CDATA[Creating and using mount points in the file system for accessing external folders and package files (e.g., <b>*.zip</b>, <b>*.ung</b>).]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates the functionality of mount points in the Engine file system.</p>
			<p><i>MountPointsSample.cpp</i> allows you to add or remove mount points for a folder and a package archive via API. If the mount point is active, an image stored inside will be loaded and displayed.</p>
			<p>Mounted paths are shown in the <i>UI</i> window, where you can toggle between mounting or unmounting each resource. Images are accessed using virtual paths defined by the mount location.</p>
			<p>The sample illustrates the concept of virtualized file access: if a resource is not available via a mount point, it will not be found or displayed by the Engine.</p>
			<p>This approach is useful for working with external content (stored outside the <b>data</b> folder), modular data loading, or switching asset sets at runtime.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>File System</tag>
	</tags>
</sample>
<sample title="File Operations" id="file_operations" category_id="app_logic">
	<sdk_desc><![CDATA[Demonstration of basic file I/O operations.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[This sample shows how you can create a text file and display its contents inside the widget via C++ API by using the <i>File</i> class. To create a text file, type the text from keyboard inside the <i>Writer</i> widget and press <b>Write</b> to save. Click <b>Read</b> inside the <i>Reader</i> widget to display the recorded information. The saved information will be displayed in the same widgets when you start the sample next time.]]>
		</brief>
	</desc>
	<tags>
		<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::getIFps()</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::getIFps()</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::getIFps()</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::getIFps()</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>
	<keywords>iFPS,deltaTime</keywords>
</sample>
<sample title="JSON" id="json" category_id="app_logic">
	<sdk_desc><![CDATA[Generation of a structured <i>JSON</i> document containing objects, arrays, and various data types such as strings, numbers, booleans, and null values, followed by traversal and pretty-printed output.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample shows how to generate a structured <i>JSON</i> document containing objects, arrays, and various data types such as strings, numbers, booleans, and null values. It also demonstrates how to traverse and print this structure recursively with indentation, imitating a pretty-printed output.</p>
			<p>The sample begins by constructing a custom <i>JSON</i> structure in memory using <i>Json::create()</i> and its child manipulation methods. Nodes are added dynamically and include both named and unnamed children of various types. Once built, the structure is traversed recursively and printed to the Console in a readable format using indentation and commas, based on node type and position. The code demonstrates how to distinguish between arrays, objects, and primitive values when printing.</p>
			<p>This sample is useful for learning the basics of <i>JSON</i> manipulation, such as creating structured data, traversing an element tree, and formatting output. It can serve as a foundation for processing <i>JSON</i> data (e.g., responses to <i>REST API</i> requests), as well as for complex serialization or debugging tools.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>File Formats</tag>
	</tags>
	<keywords>Parser</keywords>
</sample>
<sample title="Materials And Properties Enumeration" id="materials_and_properties_enumeration" category_id="app_logic">
	<sdk_desc><![CDATA[Working with <i>Property Manager</i> and <i>Material Manager</i> to access all materials and properties in the project via API.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to access all materials and properties in the project via API.</p>
			<p>The sample iterates through the list of registered in the <i>Property Manager</i> via <i>Properties::getProperty()</i> and prints out the names and child counts for each. It also gets all available materials from the <i>Materials Manager</i> via <i>Materials::getMaterial()</i>, and lists them along with their file paths and number of children.</p>
			<p>This can be used as a reference for accessing and working with project assets at runtime - whether for inspection, dynamic assignment, or content management logic.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Materials</tag>
		<tag>Properties</tag>
	</tags>
</sample>
<sample title="Type Safe Callbacks" id="type_safe_callbacks" category_id="app_logic">
	<sdk_desc><![CDATA[Using the <i>CallbackBase</i> class to wrap and call functions and class methods with various numbers of arguments.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to use the <i>CallbackBase</i> class via the C++ API to wrap and call functions and class methods with various numbers of arguments.</p>
			<p>Callback mechanism is useful in scenarios such as event-driven systems, user interface interactions, or asynchronous task management in applications requiring dynamic function invocation.</p>
			<p>Open the Console (`) to view the callback execution log.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Systems</tag>
		<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>
	<keywords>Parser</keywords>
</sample>
<sample title="Gamepad" id="gamepad" category_id="input_handling">
	<sdk_desc>
		<![CDATA[This sample demostrates the simple usage of Gamepad input.]]>
	</sdk_desc>
	<desc>
		<brief>
		<![CDATA[This sample demostrates the simple usage of Gamepad input.]]>
		</brief>
	</desc>
	<tags>
		<tag>Input &amp; Controls</tag>
	</tags>
</sample>
<sample title="Joystick" id="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.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[This sample demonstrates how to add advanced <b>joystick</b> input handling, supporting multiple controllers with real-time axis/button monitoring and force feedback effects in UNIGINE. It features dynamic UI for testing 10+ force feedback types (springs, vibrations, waves) and automatically handles device connection/disconnection events. Ideal for racing/flight simulators or any project requiring precise controller input with haptic feedback.]]>
		</brief>
	</desc>
	<tags>
		<tag>Input &amp; Controls</tag>
	</tags>
</sample>
<sample title="Keyboard And Mouse" id="keyboard_and_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, and cursor positions across different coordinate systems. It displays real-time input data including key presses, mouse deltas, and text input.]]></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. It displays real-time input data including key presses, mouse deltas, and text input. 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> - no cursor restrictions.</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.]]>
	</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.]]>
		</brief>
	</desc>
	<tags>
		<tag>Input &amp; Controls</tag>
	</tags>
	<keywords>Touchscreen</keywords>
</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=cpp</link_docs>
	<tags>
		<tag>Systems</tag>
		<tag>Optimization</tag>
		<tag>File System</tag>
		<tag>Multithreading</tag>
	</tags>
	<keywords>Asynchronous,Threads,Sync,Async,AsyncQueue</keywords>
</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=cpp</link_docs>
	<tags>
		<tag>Systems</tag>
		<tag>Optimization</tag>
		<tag>File System</tag>
		<tag>Multithreading</tag>
	</tags>
	<keywords>Asynchronous,Threads,Sync,Async,AsyncQueue</keywords>
</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=cpp</link_docs>
	<tags>
		<tag>Systems</tag>
		<tag>Optimization</tag>
		<tag>File System</tag>
		<tag>Multithreading</tag>
	</tags>
	<keywords>Asynchronous,Threads,Sync,Async,AsyncQueue</keywords>
</sample>
<sample title="CPU Shader Usage" id="cpu_shader_usage" category_id="multi_threading_performance_optimization">
	<sdk_desc><![CDATA[Multi-threaded update of multiple <i>ObjectMeshCluster</i> instances on the CPU side using the <i>CPUShader</i> class.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to implement a custom CPU shader by inheriting from the <i>CPUShader</i> class to perform multi-threaded data processing outside the main rendering loop.</p>
			<p>The system updates multiple <i>ObjectMeshCluster</i> instances asynchronously by using a helper <i>AsyncCluster</i> structure. Each cluster maintains two versions of itself: one for rendering and one for background updates. At the end of each frame, the two are swapped so the visible cluster always shows the latest result without stalling the frame.</p>
			<p>This approach is particularly effective for real-time procedural animation, large-scale mesh updates, or any CPU-side logic that benefits from multithreading while remaining synchronized with rendering.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Optimization</tag>
		<tag>Shaders</tag>
		<tag>Multithreading</tag>
	</tags>
	<keywords>CPU,Shader,CPUShader,Cluster,Update</keywords>
</sample>
<sample title="Custom Threads" id="custom_threads" category_id="multi_threading_performance_optimization">
	<sdk_desc><![CDATA[Creating and running custom threads using the <i>Unigine::Thread</i> class.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample shows how to define and manage background threads in <b>UNIGINE</b> by inheriting from the <i>Thread</i> class and overriding the <i>process()</i> method.</p>
			<p>Two custom thread types are demonstrated:</p>
							<p> - <b>InfiniteThread</b> - continuously outputs messages while running.</p>
				<p> - <b>CountedThread</b> - performs a finite number of iterations before completing.</p>
						<p>Threads are started during component initialization and executed in parallel with the main engine loop. The infinite thread is explicitly stopped via <i>stop()</i> once the counted thread completes all iterations.</p>
			<p>This sample illustrates basic principles of multithreading and can serve as a foundation for offloading computations or <i>I/O</i> operations from the main thread.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Optimization</tag>
		<tag>Multithreading</tag>
	</tags>
	<keywords>CPU</keywords>
</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="Multiple Async Raycast Requests" id="multiple_async_raycast_requests" category_id="multi_threading_performance_optimization">
	<sdk_desc><![CDATA[Launching and managing a large number of asynchronous ray-based intersection queries simultaneously.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to launch and manage a large number of asynchronous ray-based intersection queries simultaneously.</p>
			<p>The results are visualized in real time and latency statistics are displayed for performance analysis.</p>
			<p>This approach is useful for stress-testing intersection systems, profiling async request latency, or building interactive tools relying on high-frequency spatial queries.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Optimization</tag>
		<tag>Multithreading</tag>
		<tag>Intersections</tag>
	</tags>
	<keywords>Asynchronous</keywords>
</sample>
<sample title="Single Async Raycast Request" id="single_async_raycast_request" category_id="multi_threading_performance_optimization">
	<sdk_desc><![CDATA[Performing a single asynchronous intersection query based on the user's mouse cursor position in the scene.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to perform a single asynchronous intersection query based on the user's mouse cursor position in the scene. The result includes the hit point and surface normal, which are visualized in the scene, along with latency information.</p>
			<p>This setup demonstrates how to implement non-blocking intersection queries suitable for object selection or similar real-time input-driven interactions.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Optimization</tag>
		<tag>Multithreading</tag>
		<tag>Intersections</tag>
	</tags>
	<keywords>Asynchronous</keywords>
</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=cpp</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=cpp</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=cpp</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=cpp</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=cpp</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=cpp</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=cpp</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" id="navigation_mesh" category_id="navigation">
	<sdk_desc><![CDATA[Configuring pathfinding between two points with obstacles using <i>Navigation Mesh</i>.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[This sample demonstrates how to configure pathfinding between two points with obstacles using <i>Navigation Mesh</i>. The <i>Route radius</i> parameter controls the navigation width - increasing it creates wider paths that maintain safe distance from obstacles, while decreasing it allows navigation through tighter spaces.]]>
		</brief>
	</desc>
	<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.</p>
		]]>
	</controls>
	<tags>
		<tag>Navigation &amp; Pathfinding</tag>
	</tags>
</sample>
<sample title="Navigation Mesh Demo" id="navigation_mesh_demo" category_id="navigation">
	<sdk_desc><![CDATA[Configuring pathfinding to multiple targets on a plane with obstacles using <i>Navigation Mesh</i>.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[This sample demonstrates several material balls collecting coins on a plane with obstacles, navigating around by means of a <i>Navigation Mesh</i>. The <i>Route radius</i> parameter controls the navigation width - increasing it creates wider paths that maintain safe distance from obstacles, while decreasing it allows navigation through tighter spaces.]]>
		</brief>
	</desc>
	<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.</p>
		]]>
	</controls>
	<tags>
		<tag>Navigation &amp; Pathfinding</tag>
	</tags>
</sample>
<sample title="Navigation Sectors" id="navigation_sectors" category_id="navigation">
	<sdk_desc><![CDATA[Configuring pathfinding between two points with obstacles using <i>Navigation Sectors</i>.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[This sample demonstrates how to configure pathfinding between two points with obstacles using <i>Navigation Sectors</i>. The <i>Route radius</i> parameter controls the navigation width - increasing it creates wider paths that maintain safe distance from obstacles, while decreasing it allows navigation through tighter spaces.]]>
		</brief>
	</desc>
	<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.</p>
		]]>
	</controls>
	<tags>
		<tag>Navigation &amp; Pathfinding</tag>
	</tags>
</sample>
<sample title="Navigation Sectors Demo" id="navigation_sectors_demo" category_id="navigation">
	<sdk_desc><![CDATA[Configuring pathfinding to multiple targets in a cube with obstacles using <i>Navigation Sector</i>.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[This sample demonstrates several material balls collecting coins in a cube with obstacles, navigating around by means of a <i>Navigation Sector</i>. The <i>Route radius</i> parameter controls the navigation width - increasing it creates wider paths that maintain safe distance from obstacles, while decreasing it allows navigation through tighter spaces.]]>
		</brief>
	</desc>
	<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.</p>
		]]>
	</controls>
	<tags>
		<tag>Navigation &amp; Pathfinding</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 <b>github.com/yhirose/cpp-httplib</b> library is used to perform the <i>HTTP</i> requests.</p>
			<p>Once an image is retrieved, it is loaded from raw byte data using the <i>Image::load()</i> method. If successful, the image is assigned to the albedo texture slot of the target material using <i>Material::setTextureImage()</i>. The texture is applied at runtime to the specified surface of an object in the scene. If loading fails, the downloaded data is written to a file for further inspection.</p>
			<p>This sample showcases a practical approach to fetching external media assets, validating them, and using them in your scenes or application logic.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Network</tag>
	</tags>
</sample>
<sample title="HTTP Request Handling" img="yes" id="http_request_handling" category_id="network">
	<sdk_desc><![CDATA[Implementing asynchronous <i>HTTP GET</i> requests to external <i>REST API</i> and displaying the retrieved data in the user interface.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to implement asynchronous <i>HTTP GET</i> requests to external <i>REST API</i> and display the retrieved data in the user interface.</p>
			<p>For demonstration, the sample performs two consecutive requests to external weather <i>API</i> and displays the results in real time.</p>
							<p> - <b>Geocoding</b> - resolving a location by name using <i>geocoding-api.open-meteo.com</i>.</p>
				<p> - <b>Current weather conditions</b> - retrieving live meteorological data for the selected location using <i>api.open-meteo.com</i>.</p>
						<p>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>
	<keywords>REST,API,Web</keywords>
</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="Lights" id="lights" category_id="nodes">
	<sdk_desc><![CDATA[This sample demonstrates how to create light sources (<b>World Light, Projected Light, Omni Light</b>) and modify their parameters at runtime.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to create light sources and modify their parameters at runtime:</p>
							<p> - <b>World Light</b> - an infinitely remote light source casting orthographically projected beams onto the scene.</p>
				<p> - <b>Projected Light</b> - a light source that casts light from a single point forming a focused beam aimed in a specific direction.</p>
				<p> - <b>Omni Light</b> - a point source emitting light in all directions (360 degrees) and realistically reproducing shadow cast.</p>
					]]>
		</brief>
	</desc>
	<tags>
		<tag>Lighting</tag>
	</tags>
</sample>
<sample title="Node Extern" id="node_extern" category_id="nodes">
	<sdk_desc><![CDATA[Adding custom nodes created via API to the world by using <b>NodeExtern</b>. Implementation of bound box visualization and runtime node configuration while maintaining Engine integration.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>UNIGINE allows you to extend its out-of-the-box functionality in various ways, including adding custom nodes with personalized behavior, functions, and visualization (if needed).</p>
			<p>This sample demonstrates how to implement a custom user node based on the <b>NodeExtern</b> class, featuring bounding box visualization and runtime configuration of node parameters (e.g., bounding box color). These nodes can then be added to your scene via API.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Objects</tag>
		<tag>Extension &amp; Customization</tag>
	</tags>
</sample>
<sample title="Object Extern" id="object_extern" category_id="nodes">
	<sdk_desc><![CDATA[Adding custom objects created via API to the world by using <b>ObjectExtern</b>. Implementation of custom rendering, physics, and properties while maintaining full Engine integration.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>UNIGINE allows you to extend its out-of-the-box functionality in various ways, including adding your own objects with custom geometry and behavior (e.g., custom particle systems, meshes with custom culling, animated GPU-based crowd rendering solutions, etc.).</p>
			<p>This sample demonstrates how to implement custom user objects based on the <b>ObjectExtern</b> class, incorporating custom rendering, physics, and properties, while maintaining full Engine integration. These objects can then be added to your scene via API.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Objects</tag>
		<tag>Extension &amp; Customization</tag>
	</tags>
</sample>
<sample title="Player Types" id="players_types" category_id="nodes">
	<sdk_desc><![CDATA[Creation and configuration of the four <i>Players</i> available (<i>PlayerDummy, PlayerPersecutor, PlayerSpectator, PlayerActor</i>).]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to create and configure the four available <b>Players</b>:</p>
							<p> - <b>PlayerDummy</b> - a manually controlled camera that has no physical properties and cannot collide with objects.</p>
				<p> - <b>PlayerPersecutor</b> - a third-person chase camera that follows a target with adjustable distance.</p>
				<p> - <b>PlayerSpectator</b> - a free-fly camera without a physical body.</p>
				<p> - <b>PlayerActor</b> - a player with a rigid physical body, which is approximated with a capsule and has physical properties. Can only walk on the ground.</p>
						<p>Each player is instantiated with appropriate settings (collision, movement parameters, camera settings), and a GUI panel lets you <b>switch between them at runtime</b>. You can also modify camera parameters like <b>FOV and near/far clipping planes</b>.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Cameras</tag>
	</tags>
	<keywords>PlayerActor,PlayerDummy,PlayerSpectator,PlayerPersecutor</keywords>
</sample>
<sample title="Spline Graph" id="spline_graph" category_id="nodes">
	<sdk_desc><![CDATA[Creation and visualization of a spline graph (SplineGraph), and moving an object along it.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to create and visualize a spline graph (<i><b>SplineGraph</b></i>), and move an object along it. A <b>SplineGraph</b> is created at <i>Initialization</i> by adding points and segments using the <i>addPoint(), addSegment()</i> API methods, with control points placed randomly.</p>
							<p> - A cube mesh is created and added to the scene.</p>
				<p> - During the <i>Update</i> stage, the cube moves along the spline by switching between its consecutive segments and evaluating a point on it using the <i>calcSegment*</i> methods.</p>
					]]>
		</brief>
	</desc>
	<tags>
		<tag>Animation</tag>
		<tag>Water</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="Water Waves Customization Gerstner" id="water_waves_customization_gerstner" category_id="nodes">
	<sdk_desc><![CDATA[This sample demonstrates how to control the wave spectrum of Global Water in Manual mode via API]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to control the wave spectrum of <b>Global Water</b> in <b>Manual</b> mode via API over wave parameters (octaves - a set of waves at a specific size/frequency level, count per octave, length, amplitude, phase, and steepness).</p>
			<p>Because all wave parameters are managed on the CPU side, they can be dynamically generated, modified, or stored for reproducible results and external integration (for example, to process Weather Control packets from IOS).</p>
			<p>The maximum number of waves is <b>256</b>, but higher values significantly affect performance, so we recommend keeping the number below 100 and using the minimum possible number.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Water</tag>
		<tag>Maritime</tag>
	</tags>
</sample>
<sample title="Water Waves Generation Field Height" id="water_waves_generation_field_height" category_id="nodes">
	<sdk_desc><![CDATA[Creation of a dynamic <i>Field Height</i> with dynamic sine function texture using the C++ API.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>The sample illustrates the effect of simulating waves on a water surface, which is created using the <b>Field Height</b> object.</p>
			<p>The code generates a heightmap that is dynamically modulated over time by a sinusoidal function, resulting in an oscillating visual representation.</p>
			<p>This approach can be useful for creating ship wake waves, water disturbances around floating objects such as buoys, and more.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Procedural</tag>
		<tag>Fields</tag>
		<tag>Water</tag>
	</tags>
</sample>
<sample title="World Spline Graph" id="world_spline_graph" category_id="nodes">
	<sdk_desc><![CDATA[Generating spline-based geometry by creating a <i>WorldSplineGraph</i> from an <i>*.spl</i> file and applying <i>*.node</i> geometry in stretching mode for placing objects along splines.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to integrate a spline-based geometry system into a world environment.</p>
			<p>A <i>WorldSplineGraph</i> class instance is created and populated with data from an external <b>*.spl</b> file, which defines the spatial structure of the graph. Geometry is then applied to each segment using a predefined <b>*.node</b> file, rendered in stretching mode to ensure it conforms seamlessly to the shape and length of each spline.</p>
			<p>This approach allows for the efficient construction of roads, pipelines, rails, and other continuous structures within the world.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Objects</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 the 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.]]></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.</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.cpp</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="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>
	<keywords>Binoculars,Distance Scale,Zoom,Player</keywords>
</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 align=left><b>WASD</b> - move.<br/>
		<b>Space</b> - jump.<br/>
		<b>Shift</b> - run.<br/>
		<b>Ctrl</b> - crouch.</p>
			]]>
	</controls>
	<tags>
		<tag>Cameras</tag>
		<tag>Games</tag>
		<tag>Basic Recipes</tag>
	</tags>
	<keywords>Player</keywords>
</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>
	<keywords>Player</keywords>
</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>CameraOrbitSample</i> component enables orbit-style camera movement around a target object using a <i>PlayerDummy</i> node and the <i>CameraControls</i> component to process 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>
	<keywords>Player</keywords>
</sample>
<sample title="Persecutor Controller" id="persecutor_controller" category_id="player_controllers">
	<sdk_desc><![CDATA[Creating custom target-following camera using <i>PlayerDummy</i>, replicating <i>PlayerPersecutor</i> logic with adjustable offset, collision handling, and multiple follow modes.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[		This sample demonstrates a custom third-person camera built using a <i>PlayerDummy</i> node, replicating and extending the behavior of UNIGINE's built-in <i>PlayerPersecutor</i> object.		]]>
		</brief>
	</desc>
	<tags>
		<tag>Cameras</tag>
		<tag>Transformations</tag>
		<tag>Objects</tag>
		<tag>Complex Solutions</tag>
	</tags>
	<keywords>Player</keywords>
</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>Cameras</tag>
		<tag>Complex Solutions</tag>
		<tag>Physics</tag>
	</tags>
	<keywords>Player</keywords>
</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. The implementation is based on the <i>PlayerDummy</i> node.]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
		<p align=left><b>LMB</b> - select objects (either clicking on them or drawing a rectangle).<br/>
		<b>MMB</b> - move the camera.<br/>
		<b>Mouse Wheel</b> - zoom in/out.<br/>
		<b>Q</b> and <b>E</b> - rotate the camera.<br/>
		<b>Hold F</b> - follow the selected object.</p>
		]]>
	</controls>
	<tags>
		<tag>Cameras</tag>
		<tag>Games</tag>
		<tag>Basic Recipes</tag>
	</tags>
	<keywords>Player</keywords>
</sample>
<sample title="Two-Point Perspective" id="two_point_perspective" category_id="player_controllers">
	<sdk_desc><![CDATA[Simulating a two-point perspective projection using a lens shift technique implemented via a secondary <i>Dummy Player</i>.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample shows how to simulate a two-point perspective projection using a lens shift technique implemented via a secondary <i>Dummy Player</i>. When enabled, the sample dynamically adjusts the projection matrix of a dummy camera to visually align vertical lines while preserving the viewing direction.</p>
			<p>The effect is achieved by adjusting the projection matrix of a <i>PlayerDummy</i> instance according to the pitch angle of the active camera. During the rendering phase, the <i>Dummy Player</i> temporarily replaces the main camera to apply the modified view.</p>
			<p>This approach can be used for architectural visualization or stylized camera effects where a more orthographic-like vertical perspective is desired.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Cameras</tag>
		<tag>Render</tag>
	</tags>
	<keywords>ArchViz,Player</keywords>
</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 VRAM taken by their mesh data. In <i>Dynamic</i> mode the memory is measured per object at creation time and remains constant, while in <i>Blob</i> and <i>File</i> modes it is taken from the render streaming statistics and includes only the meshes used in the current frame.</p>
			<p>This makes it easier to 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=cpp#procedural_workflow</link_docs>
	<tags>
		<tag>Systems</tag>
		<tag>Objects</tag>
		<tag>Mesh</tag>
		<tag>Procedural</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=cpp#procedural_workflow</link_docs>
	<tags>
		<tag>Systems</tag>
		<tag>Objects</tag>
		<tag>Mesh</tag>
		<tag>Procedural</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=cpp#procedural_workflow</link_docs>
	<tags>
		<tag>Systems</tag>
		<tag>Objects</tag>
		<tag>Mesh</tag>
		<tag>Procedural</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 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>
	<keywords>Dig,Digging</keywords>
</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>
	<keywords>Generation,Time,Period</keywords>
</sample>
<sample title="CAD-Like View" id="cad_like_view" category_id="rendering">
	<sdk_desc><![CDATA[CAD-Like View implementation with multiple synced viewports for top, side, front, and perspective views.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[This sample demonstrates how to build a CAD-style layout by combining four synchronized views of the same scene: top, side, front, and perspective. Each view uses its own camera with a separate projection matrix - orthographic for technical views and perspective for the main one. Each view is rendered off-screen and displayed through a <i>WidgetSpriteViewport</i>.]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
<p>Use <b>ViewCube</b> or <b>LMB</b> to control camera movements.</p>
		]]>
	</controls>
	<tags>
		<tag>Systems</tag>
		<tag>Cameras</tag>
		<tag>Interface (GUI)</tag>
		<tag>Windows &amp; Viewports</tag>
		<tag>Widgets</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="Compute Shader" id="compute_shader" category_id="rendering">
	<sdk_desc><![CDATA[Implementing a GPU-based particle system with compute shaders.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates a GPU-based particle system implemented with compute shaders. It initializes a dynamic particle renderer, updates particle positions and velocities each frame using a ping-pong texture mechanism, and uses UV-mapped static meshes to influence particle behavior.</p>
			<p>These mesh-to-particle transformations are well-suited for real-time visual effects, such as fluid or smoke simulations or interactive art installations.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Render</tag>
		<tag>Shaders</tag>
	</tags>
</sample>
<sample title="Compute Shader Image" id="compute_shader_image" category_id="rendering">
	<sdk_desc><![CDATA[Creating a compute shader that processes a read-write texture on GPU (without CPU).]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to create a texture at runtime and update it entirely on the GPU using compute shaders with read-write (unordered) access. The 2D texture is dynamically created and assigned to a material's albedo slot.</p>
			<p>Each frame, the compute shader updates the texture by using simulation parameters frame time (ifps) and dispatching GPU threads in <b>32x32</b> groups. Then the shader modifies the texture content using unordered access, with all calculations and writes handled fully on the GPU. The CPU is only responsible for initial setup and parameter updates.</p>
			<p>The compute shader is used to perform custom operations on textures, allowing for real-time image manipulation or procedural content generation.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Render</tag>
		<tag>Shaders</tag>
	</tags>
</sample>
<sample title="FFP Depth-Tested Line Rendering" id="ffp_depth_tested_line_rendering" category_id="rendering">
	<sdk_desc><![CDATA[Rendering custom visual elements (lines) using the <i>FFP</i> with depth testing enabled.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to render custom visual elements (lines) using the <i>FFP</i> with depth testing enabled.</p>
			<p>The elements are drawn during the visualizer stage and properly sorted with respect to scene geometry using the depth buffer.</p>
			<p>The sample sets up a render callback via <i>Render::getEventEndVisualizer()</i>, which is used to draw a simple line segment in camera space. Drawing is performed using <i>FFP</i>, with blending and depth-testing configured manually via <i>RenderState</i> class.</p>
			<p>The scene features a red line intersecting the object. The projection matrix is modified to account for reverse depth and range remapping, ensuring correct visual sorting. The line vertices are transformed into camera space using the current modelview matrix, and rendered in screen space.</p>
			<p>This sample can be used for fast rendering of various additional or debug elements (such as semi-transparent objects, frames, <i>3D</i> grids and coordinate systems, path traces, motion trails, line-of-sight visualization etc.) while ensuring consistency with the scene content.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Render</tag>
	</tags>
	<keywords>Fixed-Function Pipeline</keywords>
</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>
	<keywords>Fixed-Function Pipeline</keywords>
</sample>
<sample title="Gbuffer Read" id="gbuffer_read" category_id="rendering">
	<sdk_desc><![CDATA[Accessing <i>G-buffer</i> textures at different stages of the rendering process by configuring a custom <i>Viewport</i> and intercepting its output at the <i>G-buffer</i> rendering stage.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to access <i>G-buffer</i> textures at different stages of the rendering process by configuring a custom <i>Viewport</i> and intercepting its output at the <i>G-buffer</i> rendering stage.</p>
			<p>A temporary viewport is used to render a selected node with a simplified pipeline to stop rendering after the <i>G-buffer</i> is filled. When the rendering reaches this stage, a callback is triggered to fetch <i>G-buffer</i> textures such as depth, albedo, normals, metalness, and roughness. These textures are then copied to user-defined render targets and displayed on screen planes using custom materials.</p>
			<p>This setup is useful for debugging, material analysis, or developing post-processing effects that require direct access to the intermediate data in the rendering pipeline.</p>
		]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
			<p><b>Main Camera</b> - main render.<br/>
			<b>Custom Camera</b> - custom camera <b>G-Buffer</b>.</p>
		]]>
	</controls>
	<tags>
		<tag>Render</tag>
		<tag>Shaders</tag>
	</tags>
</sample>
<sample title="Gbuffer Write" id="gbuffer_write" category_id="rendering">
	<sdk_desc><![CDATA[Modification <i>G-buffer</i> textures at different stages of the rendering process by injecting a custom material at the end of the <i>G-buffer</i> pass.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to modify <i>G-buffer</i> textures at different stages of the rendering process by injecting a custom material at the end of the <i>G-buffer</i> pass.</p>
			<p>An event handler is registered using <i>getEventEndOpacityGBuffer()</i>, which is triggered once all <i>G-buffer</i> textures (albedo, normal, etc.) are populated. In this callback, a custom post-material is applied to modify the contents of these textures using dynamic parameters such as influence, plasticity, and color. Temporary render targets are used to perform intermediate writes, and the modified textures are then swapped back into the pipeline.</p>
			<p>This technique allows real-time manipulation of <i>G-buffer</i> data during the rendering process, enabling custom surface effects or advanced material pre-processing.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Render</tag>
		<tag>Shaders</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 <i>renderToTexture()</i>. This is used in the <b>WidgetClock</b> example, 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> example, 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="Node To Texture" id="node_to_texture" category_id="rendering">
	<sdk_desc><![CDATA[Rendering a node into a texture using <i>Viewport::renderNodeTexture2D()</i>, and setting this texture as material's albedo texture]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to render a specific node and its children into a texture using <i>Viewport::renderNodeTexture2D()</i>. Instead of rendering the whole scene, a custom viewport captures only the target node as seen from a camera, and outputs the result into a 2D texture.</p>
			<p>The texture is then assigned as the material's albedo texture. To create clean output, the viewport is configured to skip transparent objects, velocity buffers, post-effects, and debugging visualizers. Lighting is inherited from the world, and the environment is overridden to a black cubemap to prevent background influence.</p>
			<p>This sample can be useful for rendering character previews, dynamic item thumbnails, or isolated object views directly onto surfaces.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Render</tag>
		<tag>Materials</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>
	<keywords>Metaballs,Image</keywords>
</sample>
<sample title="Render Target" id="render_target" category_id="rendering">
	<sdk_desc><![CDATA[Rendering paint splashes to a texture using the <i>RenderTarget</i> class.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to draw directly into a texture using the <i>RenderTarget</i> class. The system initializes multiple textures, including a background layer and a dynamic result texture, which then is assigned to the object's material. The <i>RenderTarget</i> is used to redirect rendering output from the main framebuffer to a texture, allowing full control over how sprites are composited. Each draw operation includes a UV-based transform to place and scale the sprite, and uses a custom material with direct access to the involved textures. After each draw, the result is blended with the background and mipmaps are generated for correct appearance at various distances. Sprites appear both on mouse clicks and automatically at random positions on the wall surface.</p>
			<p>Render states are saved and restored around each operation to isolate the off-screen rendering flow from the rest of the pipeline.</p>
			<p>This technique is suitable for creating effects like decal placement, user-driven painting, hit markers, or procedural texture overlays in real time.</p>
		]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
<b>LMB</b> - spawn a sprite at the cursor position.
		]]>
	</controls>
	<tags>
		<tag>Render</tag>
		<tag>Materials</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="Split-Screen Texture" id="split_screen_texture" category_id="rendering">
	<sdk_desc><![CDATA[Rendering views from two cameras into textures and implementing split-screen mode.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to capture views from two different cameras into separate textures and implement a split-screen layout using the C++ API.</p>
			<p>Each camera renders its output to a texture using <i>Viewport::renderTexture2D()</i>. These textures are displayed in a vertical split-screen layout using <i>WidgetSprite</i> elements, and at the same time are applied to surfaces by assigning them to the albedo slot of static mesh materials. The layout adjusts dynamically to screen size changes.</p>
		]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
<b>WASD</b> - control top car movement.<br/>
<b>Arrow keys</b> - control bottom car movement.
		]]>
	</controls>
	<tags>
		<tag>Render</tag>
		<tag>Cameras</tag>
		<tag>Widgets</tag>
	</tags>
</sample>
<sample title="Structured Buffer" id="structured_buffer" category_id="rendering">
	<sdk_desc><![CDATA[Creating a DXT compression by using structured buffers]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to compress a texture into <b>DXT1</b> format using compute shaders and structured buffers.</p>
			<p>At initialization, a compute material is loaded, and a source texture is prepared. A <i>DXT1Block</i> structure is used to hold the compressed data, with its size based on the texture's dimensions (in 4x4 blocks). A structured buffer is created on the GPU to store the output.</p>
			<p>The compute shader runs in two stages: a warm-up to trigger shader compilation and the actual compression pass. The number of compute groups is calculated dynamically from the texture size and thread group size to achieve efficient parallel execution.</p>
			<p>When compression is complete, the GPU buffer is transferred to CPU memory asynchronously. A new image with the compressed data is created in <b>DXT1</b> format and saved to a <b>*.dds</b> file.</p>
			<p>Open the Console (`) to view compression performance metrics and the saved file path location.</p>
			<p>This method offloads all heavy processing to the GPU, minimizes CPU overhead, and takes advantage of structured memory access for optimal performance.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Render</tag>
		<tag>Shaders</tag>
		<tag>Optimization</tag>
	</tags>
</sample>
<sample title="Textures" id="textures" category_id="rendering">
	<sdk_desc><![CDATA[Updating mesh albedo texture using procedurally generated image data.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to create and update procedural textures on static meshes in real time using the C++ API.</p>
			<p>Each mesh is assigned a custom-generated image, which is updated every frame using a time-based color pattern. The pixel data is written manually into an <i>Image</i> class instance, and the result is applied to the albedo texture slot of the mesh's material using <i>Material::setTextureImage()</i>.</p>
			<p>This method allows generating dynamic patterns, noise, or other procedural visuals without using compute shaders or external image files.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Render</tag>
		<tag>Procedural</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.cpp</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 Volume Object Detection" id="bounding_volume_object_detection" category_id="scene_management">
	<sdk_desc><![CDATA[Finding intersections between certain volumes (frustum, sphere, and box) and the bounding boxes of nodes.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to detect intersections between a frustum, sphere, or box and the bounding boxes of nodes. For clarity, the boundaries of the nodes are displayed in the scene, allowing for a quick visual assessment of when the nodes intersect the specified volumes.</p>
			<p>This approach can be used to implement systems for determining which objects fall within a bounding volume and triggering events, such as starting dialogues, spawning enemies, activating effects, or any other reaction.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Basic Recipes</tag>
		<tag>Intersections</tag>
	</tags>
	<keywords>Sphere,Frustum,Box,Shape,Collision</keywords>
</sample>
<sample title="Control Elements" id="control_elements" category_id="scene_management">
	<sdk_desc>
		<![CDATA[Demonstration of various types of interactable buttons and levers.]]>
	</sdk_desc>
	<desc>
		<brief>
		<![CDATA[Demonstration of various types of interactable buttons and levers.]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
		<b>WASDQE</b> - move around the scene.<br/>
		<b>Mouse cursor</b> - aim at interactive objects.<br/>
		<b>F</b> - activate buttons and levers.<br/>
		<b>Hold F + LMB (drag)</b>- manipulate Valve and Lever.<br/>
		]]>
	</controls>
	<tags>
		<tag>Triggers</tag>
		<tag>Logic</tag>
		<tag>Basic Recipes</tag>
	</tags>
	<keywords>Input,Button,Keyboard,Mouse,Interaction</keywords>
</sample>
<sample title="Create And Modify Objects" id="create_and_modify_objects" category_id="scene_management">
	<sdk_desc><![CDATA[Basics of working with Objects: creation and modification via API.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates the basics of working with <i><b>Objects</b></i> - how to create and modify objects via API, highlighting the differences between various types of objects (<i>ObjectMeshStatic, ObjectMeshDynamic, ObjectParticles</i>). <b>Objects</b> are characterized by a set of surfaces, an optional physical body and type-specific properties.</p>
				<p>In this sample, we create and configure three types of objects with interactive controls:</p>
				<p><b>1. Static Mesh Object (Material Ball)</b></p>
									<p> - Load an existing <b>.mesh</b> file <i>(material_ball.mesh)</i>.</p>
					<p> - Assigns a material to the object.</p>
					<p> - Adds a <i>Body</i> with a <i>Box-shaped</i> collision.</p>
								<p><b>2. Dynamic Mesh Object (Tetrahedron)</b></p>
									<p> - Constructs a custom <i>ObjectMeshDynamic</i> manually.</p>
					<p> - Applies a glass-like material.</p>
					<p> - Adds a <i>Body</i> with a <i>Sphere-shaped</i> collision.</p>
								<p><b>3. Particle System</b></p>
									<p> - Creates a default <i>ObjectParticles</i> object.</p>
					<p> - Configures <i>particle-specific parameters</i>, such as spawn rate and lifetime, and enables a <i>collision mask</i> for particle interaction.</p>
								<p><b>Runtime Modifications (via Sample Menu)</b></p>
									<p> - Adjust the albedo color of the <b>Static Mesh</b> material.</p>
					<p> - Modify the mesh (tetrahedron base height) in the <b>Dynamic Mesh</b>.</p>
					<p> - Tune the spawn rate of the <b>Particle System</b>.</p>
					<p> - Toggle the visualization of surfaces and physical shapes of the objects.</p>
								<p>For more complex objects, such as <i>ObjectLandscapeTerrain</i>, see the corresponding samples.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Objects</tag>
		<tag>Physics</tag>
		<tag>Effects</tag>
		<tag>Basics</tag>
	</tags>
	<keywords>Mesh,Body,Particles</keywords>
</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>
	<keywords>Mesh</keywords>
</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>
	<keywords>Sun,Position,Rotation</keywords>
</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>
	<keywords>Path,Spline,Position,Rotation</keywords>
</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>setPosition()</i> and <i>setRotation()</i>.</p>
			<p><b>Blue cube</b> uses <i>setTransform()</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>
	<keywords>Input,Keyboard,Position,Rotation</keywords>
</sample>
<sample title="Node State Save-Restore" id="node_state_save_restore" category_id="scene_management">
	<sdk_desc><![CDATA[This sample demonstrates how to save and restore the state of an arbitrary Node, which can be used to implement things like Scene serialization, Undo/Redo systems, or Game saves.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to save and restore the state of an arbitrary Node using the <i>saveState()</i> and <i>restoreState()</i> methods. In this sample we:</p>
							<p> - At <i>Initialization</i> create a <i><b>Blob</b></i> container for state storage and save the initial state of the referenced node.</p>
				<p> - Enable visualizer (a semi-transparent box) at saved position for visualization.</p>
				<p> - Save and restore the Node's state at any time by clicking the sample UI panel's <i>Save</i> and <i>Restore</i> buttons.</p>
						<p><b>Use Cases</b>:</p>
							<p> - Game saves</p>
				<p> - Undo/Redo systems</p>
				<p> - Scene serialization</p>
					]]>
		</brief>
	</desc>
	<tags>
		<tag>Objects</tag>
		<tag>Logic</tag>
		<tag>Basic Recipes</tag>
	</tags>
	<keywords>Serialization</keywords>
</sample>
<sample title="Raycast Detection And Bitmasking" id="raycast_detection_and_bitmasking" category_id="scene_management">
	<sdk_desc><![CDATA[Using raycasting for selective (mask-based) detection of intersections.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to find intersections with geometry using <b>raycasting</b> taking into account different <i>Intersection</i> bitmasks (using first 8 bits out of 32).</p>
			<p>Raycasting involves detecting intersections with scene objects along the path of a ray cast from point <b>A</b> to point <b>B</b>. This process is visualized in the sample via a laser ray representation (laser length depends on the ray length).</p>
			<p>In the <i>update()</i> method, the <i>World::getIntersection()</i> function checks for ray intersections with scene objects based on a specified intersection mask. If the ray hits an object with a matching mask (one bit at least), an intersection is detected. After that, the ray is updated and visual spark effects are rendered at the intersection point.</p>
			<p>You can change the laser's intersection mask by toggling the corresponding checkboxes. If a wall's mask bit doesn't match the laser's mask, the laser will pass through.</p>
			<p>Using raycasting makes it easy to implement various game mechanics, such as shooting or target detection during navigation.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Basic Recipes</tag>
		<tag>Intersections</tag>
	</tags>
	<keywords>Raycast,Collision,Filter</keywords>
</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>IntersectionMouseRay</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>
	<keywords>Raycast,Input,Mouse</keywords>
</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>
	<keywords>World,Node,Physical,Custom</keywords>
</sample>
<sample title="Speed Boat" id="speed_boat" category_id="simulation">
	<sdk_desc><![CDATA[Simulating dynamic wake foam behind a moving boat using a combination of <i>Orthographic Decals</i> and <i>Particle Systems</i>.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to simulate dynamic wake foam behind a moving boat using a combination of <i><b>Orthographic Decals</b></i> and <i><b>Particle Systems</b></i>. The foam effect responds to the boat's velocity in real time:</p>
							<p> - <b>Decal size</b> is adjusted based on the area covered by particles</p>
				<p> - <b>Particle lifetime, spawn rate, and velocity</b> are scaled proportionally to the boat's speed.</p>
						<p>A <b>Beaufort</b> slider allows control over sea state - from calm (<b>0</b>) to stormy (<b>8</b>) - to observe how foam reacts in different wave conditions. This setup is ideal for adding convincing surface wake and motion trails to ships or watercraft in real-time environments.</p>
		]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
		<p align=left><b>WASD</b> to control the boat.</p>
		]]>
	</controls>
	<tags>
		<tag>Water</tag>
		<tag>Maritime</tag>
		<tag>Basic Recipes</tag>
		<tag>Decals</tag>
		<tag>Effects</tag>
	</tags>
</sample>
<sample title="3D Sound" id="3d_sound" 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="Ambient Sound" id="ambient_sound" 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="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="Reverberation Zone" id="reverberation_zone" 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="Asynchronous Terrain Albedo Height Brushes" id="asynchronous_terrain_albedo_height_brushes" category_id="terrain_modification_usage">
	<sdk_desc><![CDATA[This sample demonstrates real-time terrain modification through direct manipulation of Landscape Layer Maps.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates several techniques for destructive runtime modification of the <b>Landscape Terrain</b> by altering the underlying textures of a <b>Landscape Layer Map</b> using <b>Landscape::asyncTextureDraw()</b> in combination with custom base materials.</p>
			<p>It features three distinct painting modes:</p>
							<p> - <b>Albedo Painter:</b> Allows painting of the terrain's albedo texture using a customizable brush (texture, mask, size, angle, opacity, and color).</p>
				<p> - <b>Height Painter:</b> Enables height modification using height values and scaling options, along with support for alpha or additive blending modes.</p>
				<p> - <b>Height To Albedo:</b> Converts terrain height data into albedo colorization based on a user-selected gradient and specified height range.</p>
						<p>You can dynamically change brush parameters through a UI panel (textures, masks, gradient, size, spacing, angle, opacity, and color) and visualize the brush as an orthographic decal projected onto the terrain.</p>
			<p><b>Use Cases</b></p>
							<p> - Runtime terrain painting tools for level editors and world-building interfaces</p>
				<p> - Terrain sculpting systems in games or simulations</p>
				<p> - Custom height-based texturing workflows for stylized or procedurally modified terrains</p>
				<p> - Visualization of terrain blending behavior with UI interactivity.</p>
						]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
		<b>WASD</b> - move camera<br/>
		<b>RMB</b> - rotate camera<br/>
		<b>Shift + Mouse Wheel</b> - change brush angle<br/>
		<b>Ctrl + Mouse Wheel </b>- change brush size
		]]>
	</controls>
	<tags>
		<tag>Terrain</tag>
		<tag>Objects</tag>
		<tag>Materials</tag>
	</tags>
	<keywords>Landscape,Modification,lmap,Paint,Sculpting</keywords>
</sample>
<sample title="Asynchronous Terrain Data Fetch" id="asynchronous_terrain_data_fetch" category_id="terrain_modification_usage">
	<sdk_desc><![CDATA[This sample demonstrates how to retrieve detailed information from a LandscapeTerrain object on its surface using LandscapeFetch.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to retrieve detailed information from a <b>LandscapeTerrain object</b> at any arbitrary point on its surface using <b>LandscapeFetch</b>.</p>
			<p><b>Key Features:</b></p>
							<p> - Casts a ray from the camera through the mouse cursor</p>
				<p> - Performs asynchronous intersection tests with the terrain</p>
				<p> - <p>Retrieves:</p>
											<p> - Surface <b>height</b></p>
						<p> - Surface <b>normal</b></p>
						<p> - <b>Blend mask values</b> for all configured layers</p>
						<p> - Surface albedo</p>
									</p>
				<p> - <p>Visualizes results in the viewport with:</p>
											<p> - A <b>normal vector</b></p>
						<p> - A floating <b>text box</b> showing the terrain fetch data.</p>
									</p>
						<p>This feature can be used for terrain debugging, editor extensions, dynamic content placement, and real-time visualization of terrain attributes.</p>
			]]>
		</brief>
	</desc>
	<tags>
		<tag>Terrain</tag>
		<tag>Objects</tag>
		<tag>Intersections</tag>
	</tags>
	<keywords>Landscape,Async</keywords>
</sample>
<sample title="Asynchronous Terrain Mask Brushes" id="asynchronous_terrain_mask_brushes" category_id="terrain_modification_usage">
	<sdk_desc><![CDATA[This sample demonstrates real-time painting of Landscape Layer Map mask data using a customizable brush system.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates real-time painting of <b>Landscape Layer Map</b> mask data using a customizable brush system.</p>
			<p><b>Key Features:</b></p>
							<p> - Terrain modification using <i>Landscape::asyncTextureDraw()</i></p>
				<p> - <p>Brush parameters:</p>
											<p> - Texture, mask</p>
						<p> - Size, angle, spacing, opacity</p>
									</p>
				<p> - Visual brush preview via <i>DecalOrtho</i></p>
				<p> - Powered by a custom base material (<b>landscape_mask_brush.basemat</b>) for applying edits.</p>
						<p>Ideal for runtime editing tools, vegetation control, or any system requiring dynamic terrain mask authoring.</p>
		]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
		<b>WASD</b> - move camera<br/>
		<b>RMB</b> - rotate camera<br/>
		<b>Shift + Mouse Wheel</b> - change brush angle<br/>
		<b>Ctrl + Mouse Wheel</b> - change brush size
		]]>
	</controls>
	<tags>
		<tag>Terrain</tag>
		<tag>Objects</tag>
	</tags>
	<keywords>Landscape,Async,Modification,Masks,Paint,Clutter,Vegetation</keywords>
</sample>
<sample title="Creating Detail Layers" id="creating_detail_layers" category_id="terrain_modification_usage">
	<sdk_desc><![CDATA[Adding and managing detail layers for a LandscapeTerrain object using the <i>getDetailMask()</i> and <i>addDetail()</i> methods.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to add and manage detail layers for a <b>LandscapeTerrain</b> object using the <i>getDetailMask()</i> and <i>addDetail()</i> methods.</p>
			<p>It dynamically creates and configures three types of terrain details:</p>
							<p> - <b>Grass</b></p> 				<p> - <b>Stone</b></p>
				<p> - <b>Snow caps</b> (simple white material applied based on elevation using height constraints - no texture).</p>
						<p><b>Each detail is:</b></p>
							<p> - Mapped to a separate detail mask</p>
				<p> - Assigned a custom material</p>
				<p> - Ordered visually using <i>swapRenderOrder()</i> to ensure natural blending (stone below grass, grass below snow).</p>
						<p>This setup is useful for biome-style terrain detailing, visual layering of materials, and real-time terrain customization.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Terrain</tag>
		<tag>Objects</tag>
	</tags>
	<keywords>Landscape,Modification,Details</keywords>
</sample>
<sample title="Generating Mesh From Terrain" id="generating_mesh_from_terrain" category_id="terrain_modification_usage">
	<sdk_desc><![CDATA[This sample demonstrates how to generate a procedural mesh (ObjectMeshDynamic) that represents a selected region of the Landscape Terrain.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to generate a procedural mesh (<b>ObjectMeshDynamic</b>) that represents a selected region of the <b>Landscape Terrain</b>.</p>
			<p><b>Key Features:</b></p>
							<p> - Terrain data (height and albedo) is fetched at runtime using <b>LandscapeFetch</b></p>
				<p> - Mesh resolution, position, scale, and rotation can be customized via UI</p>
				<p> - Optionally render a bounding box and wireframe overlay</p>
				<p> - <p>Ideal for:</p>
											<p> - Runtime terrain previews</p>
						<p> - Simplified <b>LOD</b> meshes or data extraction for analysis/simulation.</p>
									</p>
						<p>The generated mesh uses a basic material and includes color data sampled from the terrain's albedo layer. Use the <b>Generate</b> button to fetch terrain data and construct the mesh in real time.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Terrain</tag>
		<tag>Objects</tag>
		<tag>Mesh</tag>
		<tag>World Management</tag>
	</tags>
	<keywords>Landscape,Conversion</keywords>
</sample>
<sample title="Generating Terrain From Textures" id="generating_terrain_from_textures" category_id="terrain_modification_usage">
	<sdk_desc><![CDATA[This sample demonstrates how to dynamically generate a Landscape Layer Map using tiled albedo, height, and mask textures.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to dynamically generate a <b>Landscape Layer Map</b> using tiled <b>albedo, height,</b> and <b>mask</b> textures. The process uses the <b>LandscapeMapFileCreator</b> and <b>LandscapeMapFileSettings</b> APIs to build a fully functional <b>.lmap</b> file and configure it for use with the <b>Landscape Terrain</b> object.</p>
			<p><b>Key features:</b></p>
							<p> - Supports tile-based input with user-defined grid size and resolution</p>
				<p> - 					<p>Loads and validates image tiles for:</p>
											<p> - <b>Albedo</b></p>
						<p> - <b>Height</b></p>
						<p> - <b>Grass mask</b></p>
						<p> - <b>Stone mask</b></p>
									</p>
				<p> - Applies blend settings for each layer using <i><b>LandscapeMapFileSettings</b></i></p>
				<p> - Automatically creates and attaches the landscape objects to the world.</p>
						<p>This workflow is ideal for runtime terrain generation, procedural terrain tools, or editor extensions that need to assemble terrain data from image sources.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Terrain</tag>
		<tag>Procedural</tag>
		<tag>World Management</tag>
	</tags>
	<keywords>Landscape,lmap</keywords>
</sample>
<sample title="Height Slicing" id="height_slicing" category_id="terrain_modification_usage">
	<sdk_desc><![CDATA[This sample demonstrates a hybrid approach to terrain editing using both non-destructive and destructive Landscape Terrain modification techniques.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates a hybrid approach to terrain editing using both <b>non-destructive</b> (using multiple <b>Landscape Layer Maps</b>) and <b>destructive</b> (using <b>Landscape::asyncTextureDraw()</b> method) <b>Landscape Terrain</b> modification techniques.</p>
			<p><b>It works by:</b></p>
							<p> - Sampling height data from a <b>Source</b> Landscape Layer Map</p>
				<p> - 					<p>Using <b>Landscape::asyncTextureDraw()</b> in combination with a custom material additive height blending to modify the <b>Target</b> Layer Map if the sampled height is above the provided threshold:</p>
											<p> - The target terrain is flattened (clamped to the height threshold)</p>
						<p> - The target albedo (on the threshold height level) is painted orange.</p>
									</p>
						<p>This sample is ideal for tools that require selective terrain stamping, erosion masks, or custom terrain sculpting.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Terrain</tag>
		<tag>World Management</tag>
	</tags>
	<keywords>Landscape,Modification,Deformation</keywords>
</sample>
<sample title="Polygon-Based 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>
	<keywords>Landscape,Modification</keywords>
</sample>
<sample title="Real-Time Excavation" id="real_time_excavation" category_id="terrain_modification_usage">
	<sdk_desc><![CDATA[This sample demonstrates destructive, real-time modification of a Landscape Layer Map using a 3D object (e.g., a tractor grader) as an excavation tool.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates <b>destructive, real-time modification</b> of a <b>Landscape Layer Map</b> using a 3D object (e.g., a tractor grader) as an excavation tool.</p>
			<p><b>Key features:</b></p>
							<p> - Samples base terrain height from a <b>source layer</b></p>
				<p> - Projects the grader's <b>depth map</b> onto the terrain using an <b>orthographic camera</b></p>
				<p> - Uses a custom material (<b>digging_tool.basemat</b>) to update height data and clear mask layers</p>
				<p> - Applies updates asynchronously using <i>Landscape::asyncTextureDraw()</i></p>
				<p> - Supports full interactive movement and rotation of the grader with the <i>Manipulator</i> widget.</p>
						<p>This sample is ideal for developing terrain deformation mechanics in simulators, construction games, or any scenario requiring runtime landscape sculpting based on object interaction.</p>
		]]>
		</brief>
	</desc>
	<controls>
		<![CDATA[
		<b>WASD QE</b> - move camera<br/><br/>
		<b>C</b> - reset terrain modifications<br/>
		Grader Movement:<br/>
		<b>T</b> - translate<br/>
		<b>R</b> - rotate<br/>
		<b>G</b> - toggle local / world basis<br/>
		]]>
	</controls>
	<tags>
		<tag>Terrain</tag>
		<tag>Basic Recipes</tag>
		<tag>World Management</tag>
	</tags>
	<keywords>Landscape,Height,Modification,Deformation</keywords>
</sample>
<sample title="Real-Time Terrain Rut Deformation" id="real_time_terrain_rut_deformation" category_id="terrain_modification_usage">
	<sdk_desc><![CDATA[Non-destructive runtime modification of the <i>Landscape Terrain</i> by dynamically spawning multiple <i>Landscape Layer Maps</i> beneath moving objects to create realistic track imprints on the terrain.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates non-destructive runtime modification of the <b>Landscape Terrain</b> by dynamically spawning multiple <b>Landscape Layer Map</b> beneath moving objects (such as vehicles or characters) to create realistic track imprints on the terrain.<br/> Each track is rendered using a dedicated <b>Landscape Layer Map</b> that blends additively with the terrain&#8217;s height data and alpha blends with the albedo, producing visually convincing trails without altering the original terrain layers.</p>
			<p><b>Key Features</b></p>
							<p> - Automatic track spawning based on object movement</p>
				<p> - Track maps are spawned only when the object has moved a minimum distance (user-defined)</p>
				<p> - The number of active track maps is limited for performance (configurable limit)</p>
				<p> - Albedo and height blending are handled via standard non-destructive layering, ensuring easy track removal or replacement.</p>
						<p><b>Customizable Parameters</b></p>
							<p> - <b>Min Distance Between Tracks</b> - Controls how frequently new track maps are spawned based on movement</p>
				<p> - <b>Max Number of Track Maps</b> - Caps the number of simultaneously active track layers to manage memory and performance.</p>
						<p><b>Use Cases</b></p>
							<p> - Vehicle or character track systems for games and simulations</p>
				<p> - Temporary terrain effects (e.g., tire marks, footprints, sliding trails)</p>
				<p> - Runtime procedural content that doesn't permanently modify base terrain.</p>
					]]>
		</brief>
	</desc>
	<tags>
		<tag>Terrain</tag>
		<tag>Vehicle</tag>
		<tag>Basic Recipes</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.</p>
			<p>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 Classes" id="usc_classes" category_id="unigine_script_interop">
	<sdk_desc><![CDATA[Exporting classes from <i>C++</i> side to <i>UnigineScript</i>.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to export classes from <i>C++</i> side to <i>UnigineScript</i>.</p>
			<p>A simple <i>C++</i> class named <i>ExternClass</i> is used to export custom <i>MyExternObject</i> into the <i>UnigineScript</i> environment. This allows scripts to instantiate the class, call its methods, and interact with its properties at runtime.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>UnigineScript</tag>
	</tags>
</sample>
<sample title="Usc Functions" id="usc_functions" category_id="unigine_script_interop">
	<sdk_desc>
		<![CDATA[This sample demonstrates how to export functions from <i>C++</i> side to <i>UnigineScript</i>. It includes examples of exporting regular functions, handling multiple data types, and registering class members for a singleton-like object.]]>
	</sdk_desc>
	<desc>
		<brief>
		<![CDATA[This sample demonstrates how to export functions from <i>C++</i> side to <i>UnigineScript</i>. It includes examples of exporting regular functions, handling multiple data types, and registering class members for a singleton-like object.]]>
		</brief>
	</desc>
	<tags>
		<tag>UnigineScript</tag>
	</tags>
</sample>
<sample title="Usc Inheritance" id="usc_inheritance" category_id="unigine_script_interop">
	<sdk_desc><![CDATA[Working with <i>UnigineScript</i> containers via <i>C++ API</i>.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to work with <i>UnigineScript</i> containers via <i>C++ API</i>. It showcases class composition, constructor registration, base-to-derived linkage, and virtual method exposure within a scripting context.</p>
			<p>Each class in the hierarchy is registered via the <i>Interpreter</i> class, allowing scripts to instantiate and interact with derived types, call inherited methods, and override behavior.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>UnigineScript</tag>
	</tags>
</sample>
<sample title="Usc Stack" id="usc_stack" category_id="unigine_script_interop">
	<sdk_desc><![CDATA[Using a stack implemented via <i>C++</i> in <i>UnigineScript</i>.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to use a stack implemented via <i>C++</i> in <i>UnigineScript</i>.</p>
			<p>The sample defines a simple formatter function on the <i>C++</i> side. This function takes a format string and substitutes tokens with values popped from a runtime stack. Values are passed from the script and pushed onto the stack prior to the call.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>UnigineScript</tag>
	</tags>
</sample>
<sample title="Usc Structures" id="usc_structures" category_id="unigine_script_interop">
	<sdk_desc><![CDATA[Exposing <i>C++</i> structs to <i>UnigineScript</i> using the <i>Interpreter</i> class.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to expose <i>C++</i> structs to <i>UnigineScript</i> using the <i>Interpreter</i> class.</p>
			<p>It defines a simple <i>C++</i> structure <i>MyVector</i> with four float fields (<i>x, y, z, w</i>) and registers it. Each field is mapped via explicit getter and setter methods to allow full read/write access from the <i>UnigineScript</i> side.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>UnigineScript</tag>
	</tags>
</sample>
<sample title="Usc Transfer" id="usc_transfer" category_id="unigine_script_interop">
	<sdk_desc><![CDATA[Transfering complex data between <i>UnigineScript</i> and <i>C++</i> using the <i>Variable</i> class and the <i>TypeToVariable</i> utility.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to transfer complex data between <i>UnigineScript</i> and <i>C++</i> using the Variable class and the <i>TypeToVariable</i> utility.</p>
			<p>The example shows several ways to pass and return Image objects between script and native code. It compares direct object passing, conversion via <i>Variable</i>, and using <i>TypeToVariable</i>.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>UnigineScript</tag>
	</tags>
</sample>
<sample title="Usc Types" id="usc_types" category_id="unigine_script_interop">
	<sdk_desc><![CDATA[Enabling type conversion between custom <i>C++</i> types and <i>UnigineScript</i> using the <i>Variable</i> class.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to enable type conversion between custom <i>C++</i> types and <i>UnigineScript</i> using the Variable class.</p>
			<p>A user-defined <i>MyVector3</i> class is introduced to represent a <i>3D</i> vector. To integrate this class with the <i>UnigineScript</i> environment, custom specializations of the <i>TypeToVariable</i> and <i>VariableToType</i> templates are implemented. These allow automatic conversion between <i>MyVector3</i> and <i>vec3</i> values inside the <i>UnigineScript</i> runtime.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>UnigineScript</tag>
	</tags>
</sample>
<sample title="Usc Variable" id="usc_variable" 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>
	<controls>
		<![CDATA[
		<b>Click on control element</b> - interact with the element.<br/><b>Click on text input field</b> - activate keyboard text input.
		]]>
	</controls>
	<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 Dialogs" id="widget_dialogs" 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 Extern" id="widget_extern" category_id="user_interface">
	<sdk_desc><![CDATA[Defining a custom widget via the C++ API using <i>WidgetExternBase</i>, with full control over layout, rendering, and interaction.]]></sdk_desc>
	<desc>
		<brief>
		<![CDATA[			<p>This sample demonstrates how to create a custom GUI widget by inheriting from <i>WidgetExternBase</i> via the C++ API. The custom class overrides key methods like <i>render()</i>, <i>arrange()</i>, and <i>checkCallbacks()</i> to implement unique visual and interactive behavior.</p>
		]]>
		</brief>
	</desc>
	<tags>
		<tag>Widgets</tag>
		<tag>Interface (GUI)</tag>
		<tag>Extension &amp; Customization</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>