VectoUI Unity Converter Advanced Usage Guide

Advanced Usage Overview

This guide explains how to move from a first working build to a more controlled Unity production workflow.

Use it after you already have:

• a confirmed released or Beta path
• a working API key and design-source token
• at least one successful small-scope build

If you are still blocked by setup, go back to the integration guide first:

• VectoUI Unity Converter Integration Guide

1. Keep art-production rules aligned

Advanced usage is much easier when the design source already follows stable conventions.

Start from:

• Photoshop Art Production Guidelines
• Sketch Art Production Guidelines

The more consistent the naming, grouping, slices, and text rules are, the less “post-fix work” you will move into Unity.

2. Use naming keywords intentionally

VectoUI can attach behavior based on stable naming conventions. A practical starter set looks like this:

These rules are most useful when the whole team agrees on them early.

3. Use the component binding tool for simple cases

The component binding tool is a lightweight script attachment layer.

It works well when you want to:

• attach standard UGUI components
• map stable naming conventions to known project components
• keep simple runtime bindings out of manual prefab cleanup

Use it for simple and repeatable rules, such as:

• UI button binding
• icon or image helpers
• a small effect component that always belongs on a known node type

4. Move complex custom logic into post-build processing

Once your requirements go beyond “attach one script if a keyword matches,” use a post-build step instead of overloading naming rules.

Typical triggers for post-build processing:

• setting extra component fields after generation
• changing alignment or hierarchy based on project conventions
• injecting project-specific references
• creating additional child prefabs under generated nodes

The safer boundary is:

• simple keyword-based behavior -> component binding
• project-specific composition logic -> post-build processing

5. Example: attach custom behavior after generation

using UnityEngine;
using UnityEngine.UI;

public class GamePetIcon : MonoBehaviour
{
    void Start()
    {
        var image = GetComponent<Image>();
        image.sprite = Resources.Load<Sprite>("icons/pet_icon");
    }
}

The important idea is not the exact component above. The important idea is to keep advanced customization explicit and reviewable instead of hiding it inside design naming chaos.

6. Practical rules for stable advanced usage

• Do not use keyword binding as a substitute for messy layer structure.
• Keep advanced logic deterministic and local to the project.
• Validate changes on one representative screen before applying them broadly.
• If a path is still Beta, assume more iteration in your post-build layer.

7. When to stop adding complexity

If your team is still debugging:

• invite-only access
• token extraction
• basic first build issues
• unsupported design conventions

then you are too early for advanced customization. Solve the simple path first and keep the build reproducible before you add more hooks.