Installation - rmfandyplayz/UnityUIAnimationTools GitHub Wiki

What you need

Unity 2022.3 or newer
DOTween Pro, from the Asset Store. Plain DOTween is enough to play animations in the game, but the edit-mode preview needs Pro.
uGUI and TextMeshPro (both come with Unity)
Git installed on your computer. Unity's Package Manager uses it to download the tool from GitHub.

Steps

The tool installs through Unity's Package Manager, which is also how you update it later.

Import DOTween Pro.
Run DOTween's setup panel: Tools → Demigiant → DOTween Utility Panel → Setup DOTween…, and make sure the UI and TextMeshPro modules are ticked.
In the same panel, click Create ASMDEF.
Install the tool: Window → Package Manager, click + in the top left, choose Install package from git URL…, and paste:
```
https://github.com/rmfandyplayz/UnityUIAnimationTools.git?path=/DOTweenAnimationPlayer#release
```
That's it. Select a UI object and Add Component → UI Animation Player.

Warning

Don't skip steps 2 or 3. Importing DOTween is not the same as setting it up. If either is missing, you get seven errors in UIAnimationStep.cs, starting like 'RectTransform' does not contain a definition for 'DOAnchorPos'. They point at this tool rather than at the real cause. Click the missing button and they go away.

Note

Steps 2 and 3 are once per project. DOTween remembers them, so you don't repeat them when you update the tool.

Next: Your First Animation.

Moving over from a copied folder

Older versions of the tool were a folder you copied into Assets/. If your project has one:

Do steps 2 and 3 above.
Delete the old DOTweenAnimationPlayer folder from Assets/ before installing. Two copies of the tool clash.
Do step 4.

Everything you've already made keeps working. Your objects keep their UI Animation Player components, and your Animation Sets keep their animations, because the package uses the same script IDs as the folder did.

Warning

If you changed the tool's code in your copied folder, those changes go when you delete it. Save them somewhere first.

Updating

Window → Package Manager.
Under In Project, select DOTween UI Animation Player.
Click Update at the top right.

Unity checks GitHub and installs the newest release. The version number beside the name tells you which one you have.

Tip

Nothing updates until you click Update. A project keeps the version it has, so a new release never surprises you mid-project.

Note

The refresh button under the package list doesn't check for these updates. It only asks Unity's own package registry. Use Update.

Using it from a script

Everything is in one namespace, so any script that plays an animation needs this at the top:

using rmf_claude.DOTweenUI;

See Code API for what you can call.

Under the hood

Why the setup panel matters. The DOTween shortcuts this tool uses on UI (DOAnchorPos, DOFade, DOColor, DOSizeDelta, and the punch and shake ones) don't live in DOTween.dll. The setup panel generates them into DOTween/Modules/, so until it has run they don't exist.

Why Create ASMDEF matters. A package's code has to live in its own assembly definition. This one has two: rmf_claude.DOTweenUI for the game, and rmf_claude.DOTweenUI.Editor for the Editor only, which is what keeps the Editor code out of builds. Without Create ASMDEF, DOTween's generated shortcuts compile into Unity's predefined Assembly-CSharp-firstpass, and an assembly definition can't reference a predefined assembly. Create ASMDEF moves them into an assembly called DOTween.Modules, which the tool's assemblies reference. The tool can't check for this itself and show a friendlier message: Unity loads no code at all from a package that fails to compile, so the check would never run.

Both assemblies are auto-referenced, so your game code sees the tool with no setup of its own.

Why the .meta files matter. A .meta file holds a script's GUID, and a scene or prefab stores a component as that GUID, not as a class name. The package ships the same .meta files the copied folder had, which is why moving over keeps every component. It's also why a copied folder must always keep its metas: copy it without them and Unity makes new GUIDs, so every existing component shows up as "missing script".

Buttons wired to the old copy keep working. An On Click that calls PlayAnimation stores the class's old assembly name, Assembly-CSharp. Unity still finds the class after it moves into the package's assembly. This was checked on every such link in a real project.

The namespace (rmf_claude.DOTweenUI) means nothing in the tool can collide with a UIAnimation class your project already has. Changing a class's namespace while keeping its .meta is safe for saved scenes, since serialization only cares about the GUID.

What's where in the package:

Folder	Holds
(top level)	`UIAnimationPlayer` and `UIMaterialInstance`, the two components you add, plus `package.json` and the game assembly definition
`Data/`	What you author: an animation, a step, and the shared Animation Set asset
`Helpers/`	Sound, Custom Property lookup, stepped easing, warnings
`Attributes/`	The attributes behind the Inspector's one-row controls
`Editor/`	Editor only, with its own assembly definition: `Inspectors/`, `Drawers/`, `SceneView/` (gizmos and the path editor), `Menus/` (right-click commands)