The game is grid based and the building tiles are what you get, when you take the basic cube and set one of the scale parameters to 0,1. some of them use similar materials. Out of these tiles I’d make the buildings in the level, so larger maps would require 8000ish of these tiles to be present at the same time.
I’d give each of these tiles its own hp stat and once the hp goes to 0, a tile gets replaced with an identical looking geometry collection, and a masterfield is spawned (I know how to do that, that’s not the problem)
I know that that is doable with instanced static meshes (if I understand correctly, the hierarchical ISM only have LODs and in a game with Fog of War, that shouldn’t be an issue), I know I could spawn the tiles as sm components to an actor and of course I could just have them be singular static mesh actors but From what I understand that would lead to crazy loading times and performance issues.
I was also wondering if there might be some way to disable the rendering of the tiles’ side faces, that face towards each other and don’t contribute to the look of the whole structure. But then I’d have to be able to re-enable them if one of their neighbours gets destroyed, so the wall or ceililng doesnt look empty.
During the game, all they need to do is block certain linetraces and be interactable, when I want them to (the game is turn based, so think xcom)
I could be wrong, but having individual actors containing the single static mesh shouldn’t be an issue, as long as you disable the tick function on them. This is pretty easy to implement, so it wouldn’t hurt to test it out and see how performance is influenced.
As for rendering, I don’t think the engine can partially load static meshes based upon what is on screen. Nanite might actually do this though… would be something to try.
Unreal has a “theoretical” limit to like ~1,000 actors. after that point the overhead on the UWorld gets to be excessive, and you might encounter memory paging issues on top of that.
your biggest limitation if these are meant to be individual things is going to be reference overheads as a result I would strongly encourage pooling, or clustering
for example if a building tends to have 30-40 tiles then that could be a group. the other option is that you have a GridActor, effectively hold most if not all of your tiles and then just give it a whole bunch of the static mesh pointers laid out in the grid.
then assign the specific Static Mesh either as part of your blueprint, or as part of say procedural generation.
the GridActor can even be generated using chunks (a building might tend to be 9-ish tiles, or a river might tend to be 10x3 tiles)
you can still give each tile a collider if you want, or use some other method for tracking these hits.
you might still run into rendering issues especially on lower memory GPUs, so this would require more aggressive instancing.