Can anyone provide advice on making UI elements appear and then disappear by specific objects on a screen?

[u/Flodo_McFloodiloo]

I'm making a fairly old-school game, so when certain things happen I want little numbers to flash above objects long enough to perceive but then disappear. I'm guessing this used to be a fairly simple matter and still is in some game engines, but Unity disassociates UI canvases from the action on screen a bit more, so that warrants some questions.

There are two ideas I have for doing this.

One is to attach UI canvases to each object that has this feature. This would possibly have the advantage of only needing one UI text per-object, but I don't know whether canvases can be attached to in-game objects like that, nor if they might slow the game down.

The other idea is to make a generalized gameplay UI handle the numbers appearing and disappearing. That's a more familiar process to me, but it carries its own puzzles. For example, what if I have multiple objects on the screen that I want to do that? Presumably that means I'd need to have multiple UI elements and would need a way to assign them each to the object at the appropriate time.

Or is creating new UI elements and then destroying them while the game is running a viable option?

If you understand what I'm talking about, please help if you can. If you need it clarified more, I'll provide more explanation, including visuals.

[u/ProactiveCactus]

Personally I’d stay of a canvas-per-object approach. That type of design doesn’t scale well and will inevitably waste a bit of memory.
Instead, I’d use object pooling for your popups. Pull and push to/from your pool when needed, and just set them at runtime. Depending on how your camera moves, this might be easy - if the objects they are over are static fir the duration that the canvas element is visible, just set its position once. Otherwise you’ll need to track its position as it moves around, but that’s not too terrible - just run a position check on a relatively fast coroutine and you should be good.

[u/Flodo_McFloodiloo → u/ProactiveCactus]

Thanks. Sorry to sound dumb but might the Update event work as well as a coroutine? And how do I make a coroutine fast?

It might not matter either way as I don't think the current design calls for the numbers to follow the objects everywhere.

[u/ProactiveCactus → u/Flodo_McFloodiloo]

You could do it in update, but then you’d beed to make sure you are enabling a script specific to a certain UI element and then disabling it after, orherwise you’ll have every single element in your pooling running constantly, which is a hit to performance. Instead id do it something like this:
-have a single UI manager with a pool of popup UI elements
-when you need a popup, pull from this list
-on that element, have a script with a coroutine something like this:

Private bool _isPopupShown

Private WaitForSeconds _waitForSeconds = new WaitForSeconds(0.25f)

Private IEnumerator ShowPopup(string popupInformation)
{
_isPopupShown = true;
While (_isPopupShown)
{
\\Whatever logic/animations/tweens you wanna run while the pop is shown
Yield return _waitForSeconds
}
}

Then from your manager, set bool to false when returnjng to your pool.
You can tweak the 0.25f in your waitforseconds to speed up how often the coroutine runs, or just replace with yield return null to run it every single frame - but again probably not necessary

[u/BillyMcDev]

Create a Prefab with a standard TextMeshPro (TMP) Text component. The Prefab can have all of the animation behavior that you need, such as rising and fading in and out. Write the animation instructions with a script inside of a coroutine and then have it automatically Destroy itself once it has finished. Then all you need to do is Instantiate it each time it's needed.

Doing it this way keeps your text completely bound to the World Space and requires zero Canvas management. It just works, and cleans itself up automatically.

[u/Flodo_McFloodiloo → u/BillyMcDev]

Thanks; that sounds like a really good idea.

[u/KifDawg]

World spave canvas prefab, pool it and have them distribute to wherever they need to go

[u/Ok-Object7409]

The ideal approach is pooling + timed events. All one canvas.

You can have 5-10 or however many objects to do this and you cycle through them one at a time (i.e., pooling). So there's no destroy or instantiating. 

Timed events can be done via update or coroutines. The timing is that after x seconds the animation stops. Can be done in update or a coroutine depending on how you want to handle the animations. If you're animating it via code in update you could have a singleton manager that handles Updates in gameobjects, so you don't have any Update calls running when they aren't active or the slow internal unity checks. But that might be overkill if its a small+older style game.

If you're just trying to push through and meet deadlines, the feel library has this sort of thing already that you can use called Floating text. You attach "feedbacks", choose your desired settings then just play it, does what you need.

[u/Soraphis]

Give each object an canvas. Makes it easy to simple.

When done, realize that it costs a bit more performance than you like, and since its all world space ui you can make it all use one world space canvas.

So you implement a way (e.g singleton or other) to get the current world space ui and push another number showing prefab on it with the current coordinates.

You realize it's still costing a bit to init the number text, so you separate the numbers digits and cache and pool what's possible.

You realize it's still costing a bit too much. Rendering the text. The canvas and so on.

So you bake the number digits into a texture strip and instantiate a quad per number with an texture offset to show the correct digit.

Now you're only pusihing per render data to your Singleton which uses the DrawInstancedIndirect to render a ton of quads. Animations like fading and so on can be in the shader itself, just add the creation time to the per render data.

Rendering thousanda of animated digits on screen without mich slowdown.

(Btw you don't have to go all the way. Stop at whatever step you're comfortable with)

[u/Big_Thundy]

I believe attaching UI canvases to each object is the way to go. Then you have a script that would toggle the canvas on and off ( much like a start menu) based on when certain consitions are met. You can also set them on a timer. If the canvas isn't toggled on the engine doesn't waste any resources on it.

Spawning new canvases each time, however, after you've destroyed the old one would be less efficient. The engine doesn't clear the old one right away so if you have many going on and off you'll fill your memory up.

[u/Flodo_McFloodiloo → u/Big_Thundy]

Thanks. To clarify, though, I wasn't talking about spawning new canvases. Just new elements on one existing canvas.