DEV Community: Octanta Studio

Touch Effects in Mobile Games. Implementation via Unity Shaders + AI

Octanta Studio — Tue, 07 Oct 2025 11:49:18 +0000

Recently, our team at Octanta Studio released the Touch Effect System asset. Initially, we were looking for a way to implement a heat trail from touches, and the most optimized way to do this in Unity for mobile turned out to be through UI shaders.

The mechanism is as follows: the shader fully controls the behavior of the graphic effect, the material from the shader is applied to a UI particle, and the particle is reused at touch locations. Later, we realized that this solution is not only for trails but also for regular touch effects that do not require drawing, are flexible in customization, and reduce CPU load.

Why Touch Effects are Needed

At first glance, touch effects are decorative, like a bow on the side. However, they are one of the important details necessary for improving UX, like any other VFX. The user gets immediate and tangible feedback on their actions. According to our observations, touch effects are especially common in Japanese F2P mobile games as a means of increasing engagement. In some games, monetization is built around "skins" for touch effects (e.g., Fruit Ninja). In others, they are used as a pleasant little addition that enhances immersiveness (e.g., touching the ground in Gwent). Here are some interesting studies on this topic:

On how tactile feedback (haptics + visual effects) solves the problem of the "incorporeality" of games, reducing the distance between the person and the screen. Link 1
On the positive impact of tactile feedback on reward perception and behavioral motivation. Although the article is more about vibration as a means of encouraging sales, this also applies to visual effects. Link 2
On how the audio-visual experience increases engagement and can stimulate clicks/purchases - a common practice in live-service/gacha games. Link 3
On how visual effects adjust other methods of responding to user input. Link 4

Besides direct dialogue with the user through the screen, visual feedback can be used for other development purposes: for example, for recording mobile screens during testing; for creating tutorial hints that simulate touches on necessary buttons; for replacing heavy world effects.

It is important that touch effects do not slow down the game or interfere with UI readability, so priority #1 when creating the Touch Effect System was optimization, and #2 was flexibility in customization. In addition to the prepared shaders and settings, we provide a guide for other developers on how to independently implement any touch effect using AI.

Why UI Shaders are the Best Solution for Touch Effects in Unity

Visual Flexibility. Effects - gradients, glows, animations - are calculated mathematically. Colors, highlights, blur, or outlines can be adjusted with sliders. There is no need to draw or keep packs of textures in the project.
Minimal Size. The shader for the circle example weighs ~6 KB, the material ~1.3 KB. That's all that's needed for the effect.
Performance. Animations are computed inside the shader, without changing Transform or Canvas components. This reduces CPU load. Relevant for mobile.
Since it's UI, the effects work on top of any graphics, regardless of the pipeline (URP/HDRP/Built-in).

Writing Your Own Shader for a Touch Effect

Here is an example of a shader for a basic touch effect in the form of a circle. There is also an example of a more complex shader for a stain effect with random shape generation. And an example of a complex shader with animation that simulates touching a matrix. The last two are shown in the video.

Shader "UI/TouchPointCircle"
{
    Properties
    {
        // Core system properties - managed by TouchGlowUI script
        [HideInInspector] _MainTex ("Texture", 2D) = "white" {}
        [HideInInspector] _TimeNow ("Time Now", Float) = 0
        [HideInInspector] _StartTime ("Start Time", Float) = 0
        [HideInInspector] _Lifetime ("Lifetime", Float) = 2.0

        // Core animation properties
        [Toggle] _Scaling ("Disappearing Scaling", Float) = 0
        [Toggle] _Fading ("Disappearing Fading", Float) = 1

        // Core layer properties - solid center of the particle
        _CoreColor ("Core Color", Color) = (1, 1, 1, 1)
        _CoreSize ("Core Size", Range(0.1, 0.4)) = 0.25
        _CoreOpacity ("Core Opacity", Range(0.0, 1.0)) = 1.0

        // Glow layer properties - soft outer illumination
        _GlowColor ("Glow Color", Color) = (1, 1, 1, 1)
        _GlowBlur ("Glow Blur", Range(0.0, 1.0)) = 0.3
        _GlowOpacity ("Glow Opacity", Range(0.0, 1.0)) = 0.3

        // Ring layer properties - optional outer ring structure
        _RingColor ("Ring Color", Color) = (1, 1, 1, 1)
        _RingThickness ("Ring Thickness", Range(0.01, 0.1)) = 0
        _RingOpacity ("Ring Opacity", Range(0.0, 1.0)) = 0

        // Platform optimization and touch behavior properties
        [HideInInspector] _UseMobileOptimization ("Use Mobile Optimization", Float) = 0
        _OneTouchHoldAge ("OneTouch Hold Age", Range(0.0, 1.0)) = 0
        [Toggle] _HoldingForbidden ("Holding Forbidden", Float) = 0

    }

    SubShader
    {
        // UI transparency rendering configuration
        Tags { "RenderType"="Transparent" "Queue"="Transparent" "IgnoreProjector"="True" }
        Blend SrcAlpha OneMinusSrcAlpha
        Cull Off
        ZWrite Off
        ZTest LEqual

        Pass
        {
            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma target 2.0
            #include "UnityCG.cginc"

            struct appdata { float4 vertex : POSITION; float2 uv : TEXCOORD0; };
            struct v2f { float4 pos : SV_POSITION; float2 uv : TEXCOORD0; };

            // Shader property declarations
            sampler2D _MainTex; float4 _MainTex_ST;
            float _TimeNow, _StartTime, _Lifetime;
            fixed4 _CoreColor, _GlowColor, _RingColor;
            float _CoreSize, _CoreOpacity, _GlowBlur, _GlowOpacity, _RingThickness, _RingOpacity;
            float _Scaling, _Fading;
            float _UseMobileOptimization;

            v2f vert (appdata v) {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                return o;
            }

            fixed4 frag (v2f i) : SV_Target {
                // === PARTICLE LIFETIME MANAGEMENT ===
                float age = (_TimeNow - _StartTime) / _Lifetime;
                if (age < 0.0 || age >= 1.0) return float4(0, 0, 0, 0);

                // === COORDINATE SYSTEM AND DISTANCE CALCULATION ===
                // Circle uses standard Euclidean distance from center
                float distance = length(i.uv - 0.5);

                // === SIZE SCALING OVER LIFETIME ===
                float sizeScale = 1.0 - age;
                if(_Scaling == 0)
                {
                    sizeScale = 1;
                }                

                // === LAYER GENERATION SYSTEM ===
                // Core layer - solid center with sharp edges
                float core = step(distance, _CoreSize * sizeScale);

                // Glow layer - soft outer illumination with blur control
                float glowRadius = 0.35 * sizeScale;
                float glowSoftness = 0.1 * _GlowBlur;
                float glow = 1.0 - smoothstep(glowRadius - glowSoftness, glowRadius + glowSoftness, distance);

                // Ring layer - optional outer ring structure
                float ringRadius = min(0.42 * sizeScale, 0.42);
                float ringInner = ringRadius - _RingThickness;
                float ringOuter = ringRadius;
                float ring = smoothstep(ringInner - 0.02, ringInner, distance) * 
                           (1.0 - smoothstep(ringOuter, ringOuter + 0.02, distance));

                // === FADE EFFECTS ===
                // Edge fade prevents artifacts at texture boundaries
                float2 edgeDistance = min(i.uv, 1.0 - i.uv);
                float edgeFade = smoothstep(0.0, 0.05, min(edgeDistance.x, edgeDistance.y));

                // Time fade creates natural particle death animation
                float timeFade = 1.0 - age;
                 if(_Fading == 0)
                {
                    timeFade = 1;
                }       

                // === LAYER COMPOSITION ===
                // Calculate alpha values for each layer
                float coreAlpha = core * _CoreOpacity * timeFade * edgeFade;
                float glowAlpha = glow * _GlowOpacity * timeFade * edgeFade;
                float ringAlpha = ring * _RingOpacity * timeFade * edgeFade;

                // === OPTIMIZED COLOR BLENDING ===
                // Determine layer dominance without branching using step functions
                float finalAlpha = max(max(coreAlpha, glowAlpha), ringAlpha);
                float coreWeight = step(max(glowAlpha, ringAlpha), coreAlpha);
                float ringWeight = step(glowAlpha, ringAlpha) * (1.0 - coreWeight);
                float glowWeight = (1.0 - coreWeight) * (1.0 - ringWeight);

                // Blend colors based on layer weights
                float3 finalColor = _CoreColor.rgb * coreWeight + 
                                  _RingColor.rgb * ringWeight + 
                                  _GlowColor.rgb * glowWeight;

                return float4(finalColor, finalAlpha);
            }
            ENDHLSL
        }
    }
    Fallback "UI/Default"
}

Get all examples via GitHub →

To create your own touch effect based on these, upload them all to your neural network as examples. And use a prompt like this, provide a description of what kind of touch effect is needed:

We are developing a Unity UI touch effect system. Your task is to create a new particle type based on the existing architecture. Work will be done sequentially, task by task, and must follow the established system design. The new particle must maintain the existing lifecycle, including initialization, update, and destruction logic. It should support movement disabling, edge margins, smooth transitions, and holding behavior. Visual disappearance must be controlled by the variables disappearing scaling/fading, which should directly affect the fade-out and scaling during disappearance. The _HoldingForbidden and _OneTouchHoldAge logic must be implemented identically to the samples (if true, the particle disappears at the place of appearance, if false, follows the input). All other variables should control visual parameters visible in the Inspector. For internal animations or randomness, if needed, use simple mathematical operations optimized for mobile devices. If the effect is initially invisible, it’s better to create a preview similar to the impact effect to make editing in the Inspector more visual and convenient. Be very careful with internal variables. Follow the existing samples as a reference. Start with a simple implementation. The effect should look like: [...]

The general architecture is important:

The life cycle is needed to animate the touch effect from appearance to complete fade-out. By moving this logic to the shader, there is no need to animate (scale/fade) objects on the scene itself. There is no need to adjust complex and diverse material properties, only update the lifetime so that the particle animates itself according to the shader formula.
The ability to disable movement determines whether the touch effect will follow the touch or appear and fade in one place independently of it.
Margins from edges are needed so that the effect fits within the square UI particle and is fully visible.

Testing

Create a material from your new shader (Right-click > Create > Material).
Assign this material to the GlowMaterial slot of the TouchGlowUI script (e.g., on a prefab like TouchCircle).
Test in the scene.

The AI might not get it perfect on the first try. Iteration is key. Tweak your prompt and the description based on the results.

Once the visual is right, explore the Input Controller's advanced settings:

Trigger effects only on UI elements or objects with specific tags.
Call effects manually from your own scripts for specific game events.
Pair the effect with a sound.
Transform a one-touch effect into a Trail by emitting multiple particles in sequence - this is exactly how our heat trail is implemented.

Contacts

Touch Effect System Asset page: https://u3d.as/3C7x

If you need:

A custom touch effect developed specifically for your project.
Technical support while building your own.

Reach out to us:

Email: octantastudio@gmail.com.
Discord: Join Octanta Studio channel https://discord.gg/6SPxKpFZFC and use branch ‘to-developers’. We will provide an answer or create a special YouTube tutorial.

Tutorial. The sworn enemy of players and developers

Octanta Studio — Thu, 27 Feb 2025 14:55:44 +0000

If you explore the internet, you'll discover an interesting fact: usually both players hate tutorials, and developers hate making them. Sources: [1], [2], [3].

It's a thankless but necessary thing for mutual understanding. The highest skill is when a game - "show, don't tell" - guides itself, encourages experimentation, and doesn't need those unfortunate fingers or windows. And when they do exist, it's better for them to be well-thought-out.

Not like when a hint freezes the game, forcing you to watch as text is leisurely typed one letter at a time. Not like when a hint appears and an accidental touch closes it, never to be seen again. And not like when an interaction hint only appears when approaching in a bent-over position from a certain side.

In Automatic Tutorial Maker for Unity we've already thought through most of these nuances. For example, solving the problems above:

⚙️ Choose zoom/fade/slide animation for hint appearance and a duration of 0.5 sec.
⚙️ Set a minimum time for the hint to exist - 1.5 sec. Or add a mandatory confirmation button.
⚙️ Activate the hint asynchronously when approaching the target through Vector3.Distance.

And here are two paragraphs from the book "The Art of Game Design: A Book of Lenses". Both explore how developers can better explain things to players.

The ability to think like a player. "Where does this location intuitively lead me, and where might I get stuck?"
Playtests and adaptation. If explanations become necessary, write accompanying phrases in a notebook. This is the potential tutorial that needs to be beautifully integrated into the game. Either in the words of characters or in the geometry of the scene.

Actually, at the core of ATM are these two things: the developer sits down and walks the player's path while showing it. This generates basic hints, and it also allows you to review the game through different eyes one more time. To test and improve the tutorial logic while remaining calm about the technical part.

🎮 This is reminiscent of King of Thieves: a mobile game where before saving traps in your dungeon, you need to complete them yourself.

👀 And it also somewhat resembles hunting. To capture the player, you need to think like a player, and also spy on them from your developer bushes, again and again.

Automatic Tutorial Maker (ATM) is a tool that not only automates routine tasks but also rethinks the approach to creating tutorial systems. By taking care of the technical implementation (animations, timings, trigger conditions), it frees the developer from "coding for the sake of coding," allowing them to focus on what truly matters — logic that doesn’t frustrate the player. No more spending hours debugging pop-ups or calculating trigger distances for hints. Instead, you can immerse yourself in the player’s role: analyze where they might get stuck, how to guide them without words, and what level metaphors can make the learning process feel natural. ATM transforms tutorial creation into a dialogue with the player: you design the experience, the tool brings it to life, and the resulting mechanics work like an invisible guide — unobtrusive yet reliable. This isn’t just about saving time; it’s an opportunity to turn a mandatory step into a chance to surprise: when the tutorial becomes part of the game rather than an interruption, players don’t rush to skip hints, and developers don’t dread creating them.

Automatic Tutorial Maker for Unity: How to Speed Up In-Game Guide Creation

Octanta Studio — Mon, 17 Feb 2025 16:41:06 +0000

Hello! Our team at Octanta Studio introduces Automatic Tutorial Maker (ATM), a Unity tool designed to simplify in-game tutorial creation by automating the process. Just demonstrate actions once, and ATM generates a customizable, step-by-step guide for players. Good for freelancers, outsourced projects, and developers who frequently build casual or unconventional games.

ATM is available on the Unity Asset Store:
☝️ https://u3d.as/3tsL

This asset is optimized for 2D, 3D, UI, and supports desktop (mouse/keyboard) and mobile (touch input). Whether you’re teaching players how to open an inventory, swipe, or perform drag-and-drop, ATM handles it all.

How It Works

ATM records your actions in real-time during gameplay and converts them into tutorial steps. Each step includes visual hints (pointers, graphics, animations) and tracks player progress. For example:

Clicking the "I" key to open the inventory → Generates a step with a text graphic element on Canvas: "Press I."
Dragging a pear into a basket → Creates a step with a drag-pointer and target highlight, and text tip.

Quick Setup

Import the ATM package into your Unity project.
Add the TutorialSystem prefab to your scene and unpack it.
Assign your scene’s Main Camera and UI Canvas to TutorialSceneReferences.
Run Play Mode, press "Start Recording" in the ATM component during Play Mode. Maximize Game window (recommended) and perform the actions you want to teach.
Press "Stop Recording" to save the tutorial.

Done! The system auto-generates visual hints and tracks player input. If you enter Play Mode again, you will see generated tutorial as a player.

Key Features

Feature
Action Recognition: Supports clicks, holds, swipes, drag-and-drop, key presses (WASD, etc.), and more. Detects UI, 2D, and 3D targets automatically.
Customizable Visuals: UI/World Pointers: Arrows, hands, geotags. UI/World Graphics: Popups, sidebars, swipe animations, text. Animations: Fade, slide, pulse, or create your own.
Progress Saving: Player progress is saved via JSON between sessions. To clear memory for testing, there is a special "Reset Tutor" button in SSP component in the inspector.
Advanced Step Control: Run steps in parallel. Trigger steps manually via script. Localize hint text dynamically.
Optimized Performance: Minimal CPU/GPU impact. Animations use lightweight math operations. Caching targets for pointer hints and clearing memory after steps are executed.

Supported Visuals: UI & World Hints

ATM offers a wide range of visual hints to guide players. These visuals are divided into UI and World, each with customizable animations and behaviors.

UI Visuals

UI Pointers: Arrows, hands, or mouse icons on Canvas that point to target elements (2D/3D/UI) and are dynamic. Example: A hand pointer over the UI button with text: "Click here to open the menu".
UI Graphics: Static or animated elements on Canvas like popups, sidebars, or swipe animations. Unlike pointers these elements are not tied to a specific target. Example: A popup with text: "Click anywhere to continue."
UI Hovers: Additional Pointers highlighting the final target (e.g., highlighting inventory slot).

World Visuals

World Pointers: Arrows, geotags, or frames in world coordinates that point to target elements (2D/3D/UI) and are dynamic. Example: A 3D arrow pointing to a door: "Go here to exit."
World Graphics: Text or particle effects placed in world coordinates. Example: A highlighted static area that the player must enter, with a floating text facing Camera: "Enter the void."

All visuals support custom animations (fade, slide, pulse) and can be easily replaced with your own prefabs.

Code Snippets for Advanced Use

For example, trigger steps via script

[SerializeField] private TutorialSceneReferences sceneReferences;  
void StartTutorial() {  
    sceneReferences.StartTutorialStep(0); // Start step 0  
}

or for asynchronously running a step without disabling others:

[SerializeField] private TutorialSceneReferences sceneReferences;  
void StartTutorial() {  
    sceneReferences.AsyncStartTutorialStep(0); // Async start step 0  
}

Translate hints at runtime

sceneReferences.ChangeStepVisualText(0, "Presiona I", TextToChange.PointerText);

Force complete a step

sceneReferences.ForceCompleteStep(2); // Skip step 2

Step Customization: Tailor Each Tutorial Step

In addition to recording, a Unity developer can manually use the flexible step system to customize the tutorial.

Example: Customizing a Click/Touch Step

Set Interaction to Click.
Set Check Interaction to By GameObject.
Add the target object to GameObjects list and set it`s type (UI/2D/3D) in ObjectTypes list.
Assign a UI Pointer to highlight the target object.
Add text: "Click the object X."

For dynamic/procedurally generated content use Check Interaction: ByTag or ByLayer or set targets manually via StartTutorialStepWithTargets method.

Comprehensive documentation with AI support

Automate repetitive tasks by recording tutorial in minutes instead of hours. Quickly resolve misunderstandings with prefabs and a gallery of templates, such as “Tap to continue” popups and keyboard hints. For full asset support, use the PDF documentation and the AI Helper file to save time on research.

Freelancers and studios can quickly onboard clients with clear tutorials. Casual developers can reuse tutorial logic across similar projects, while innovative developers can explain unconventional mechanics without frustration.

Documentation

Full Docs: GitBook

In-Game Photo Camera in Unity: Tutorial

Octanta Studio — Mon, 23 Dec 2024 06:58:35 +0000

Hello! Our team at Octanta Studio recently launched the Dynamic Photo Camera asset, enabling in-game photography mechanics with rich interactivity and integration options. This article will guide you through how it works and what can be achieved using this asset.

Dynamic Photo Camera is available on the Unity Asset Store: https://u3d.as/3qTN

The asset is optimized for PC, mobile, 2D, and 3D projects. It simplifies the development of quests, interactive educational projects, and mechanics involving user-generated content. As a developer, you save time, while the user gains greater freedom of action.

🔰 Beginner friendly.

Basic Photography

This feature allows player to take screenshots of any part of the screen during gameplay and save them to the game’s memory for later use. This way, the player can leave hints for themselves instead of taking notes in a real notebook with a pen or using mobile notes or a phone camera.

How it works

Hold the click or touch anywhere for 1 second to activate the photo capture. The captured photo is saved in the in-game collection. This is done by capturing screenshot from the specified camera view, cropping it around the click point and creating a texture from it for the photo Image. Textures & photo data are saved in Application.persistentDataPath in explorer.

How to set it up (~1 minute)

Import the Dynamic Photo Camera package to your Unity project. Import the TextMeshPro package if required.
Add the PhotoController Prefab to your game scene.
In the InputController inspector, assign your active camera to the Current Camera field and disable prefab`s camera.

Recommended: unpack prefab and move UICanvas content to existing Canvas or vice versa so UI elements don`t ovelap. The UI elements and photo prefab can be customized to match your desired visual style.

Done! Run your scene, capture a photo by holding the interaction for 1 second, and verify the photo appears in the collection.

Additional

Use the Photo Settings scriptable object to adjust both the size of the photo cards and the capture area. A larger crop size will allow more content to be captured within each frame. A smaller crop size will zoom and may produce low-quality pixelated images.
Also experiment with the Camera settings, as it is the source of the image. For example, select Temporal Anti-aliasing for Rendering. You can also use a disabled camera that renders specific layers to capture the invisible. 💡 Thus, for example, the player can take pictures of people and identify vampires among them, as they are not rendered.
To modify screenshot capture properties via script, use the MakeScreenshot method in PhotoController.cs. The key line is: targetTexture = RenderTexture.GetTemporary(photoSettings.resWidth, photoSettings.resHeight); You can customize it according to your graphics requirements. For example: targetTexture = RenderTexture.GetTemporary(photoSettings.resWidth, photoSettings.resHeight, 24, RenderTextureFormat.ARGB32);

List of all possible formats: https://docs.unity3d.com/6000.0/Documentation/ScriptReference/RenderTextureFormat.html

Data Recognition & Photo Description

Every photo captured has a description that can display coordinates, the name of the recognized object, or custom metadata. This feature enriches gameplay by providing detailed information about photographed objects and enabling interaction with in-game content. It allows players to explore and learn about the game world, as well as complete “photo hunt” photography-based quests by capturing specific objects. 💡 For example, create an educational game for children where their task is to learn to identify birds by taking photographs of correct ones in trees.

How it works

When taking a photo, the system uses a raycast combined with an overlap cube to determine the camera’s focal point. It identifies the intersection with the nearest collider and stores data about the object associated with that collider in the photo memory. By default, this includes the photographed object’s name and its world coordinates. Objects can also be configured to transmit additional custom data.

By hovering over or touching photo, the player can view the stored data and gather information about the game world.

How to set it up

Ensure all objects you want to recognize in photos have any Collider component and either visible mesh or ObjectToPhoto.cs script (for 2D Sprites, for example).
For custom description attach the ObjectToPhoto.cs script to the object in the scene. In the inspector, assign PhotoController to the Controller field and fill Custom Description field.

Done! Run your scene, capture a photo of object with a custom description, hover over it in the collection and check the description.

Additional

Use the Photo Settings scriptable object to adjust Sphere Radius. A smaller value results in a thinner ray, making object recognition more precise.
Object Recognition can also be configured using a script. The description of the recognized object is passed to the RaycastCheck method in the PhotoController at the time of the photo being taken (dataString). Customize the behavior of the RaycastCheck method in the PhotoController.cs to better fit your specific requirements.
Change description`s UI on the scene (DynamicPhotoDescription object) and via script in the ConfigureDescriptionPanel method in PhotoUIManager.

Photo Validation

This feature enables objects in the game world to recognize description of the photo when the player drags and drops it onto the object. In this way, the objects read the content of the photo and can react to it. 💡 For example, a terminal recognizes the correct password, or a character recognizes a location based on coordinates, or the in-game directory provides information about the car by its number.

How it works

When a player drags a photo, aims it at an object in the game world, and drops it, a check is triggered for a detector object. If one is found, the description of the photo is passed to it, and the detector object responds with whether it’s what it needs.

How to set it up

Make sure that the validator object has any Collider and the PhotoDetector.cs script.
Fill Required Photo Data field. This field must match the Custom Description of the captured object (and photo description accordingly) for validation to succeed. For example, the validator object requires the car number AS 891 RX for input, and the full description of the photo of the blue car contains exactly “AS 891 RX”.

Done! Run a scene where there is a recognizable object with the required data and a validator object that needs this data. Take a photo of the object, drag it to the validator, and trigger a reaction.

Additional

Object validation and photo data transfer can be configured via script.
The detector object is searched for in the CheckHitOnDrag method in the PhotoPrefab.cs as follows:
if (photoData != null && hit.collider.TryGetComponent(out PhotoDetector detector))
The entire PhotoDetector.cs is responsible for the logic of recognizing the received data. ValidatePhotoData, SetDetectorState, OnActivate and OnError methods. Use them to customize your activation effects.

Conclusion

These three described functions are basic and essential in Dynamic Photo Camera asset.

Capture in-game photos
Recognize game objects in photos
Validate object data in photos

Use this article to work better with the asset, and don’t forget that the documentation and our support on Discord are always available.

Thank you.