Material changes are expensive to our frame time, we can avoid rebinding textures between materials, which in turn lets us instance more stuff together.
A resource that goes hand-in-hand with Sprite, allowing you to define Tiles from a Tileset image so they can be painted into a scene. You will also be able to apply metadata like tags to tiles for things like custom footstep sounds on different materials.
This tool will let you paint Tiles into your scene by creating TilesetRenderers for each layer and giving you options for collision, depth, ect.
Replace our current shader compiler DXC with Slang, a modern shader language with features like interfaces, generics, and modules. This gives us a more expressive and maintainable shader codebase with better tooling support.
We can break static meshes into meshlets / fragments and render them very efficiently, combining draw calls into indirect multi draw calls as well as using GPU occlusion culling. A static map or level can be entirely composed of these for huge benefit.
Instead of having to place volumes and configure them, we should be able to voxelize the entire scene (within reason) to figure out where to place probes.
This will let you define the way that certain Tiles connect to one-another so you can paint with an Autotile brush and it will automatically place the correct tiles given the surrounding tiles.
Similar to Models, this will let you define attachment points on your sprite, adjusting it's position for each frame in an animation. This can be used to attach hats to a Head attachment, or having projectiles fire from a Muzzle attachment.
Provide a set of starter project templates - FPS, third person, sandbox, blank - so creators can hit the ground running with a working foundation instead of starting from scratch every time.
Automatically generate levels of detail for meshes on import, so creators don't have to manually author LOD chains. The system should produce good quality reduced meshes with minimal effort.
We want to batch render as many UI elements together as possible, significantly reducing our draw call overhead and improving frame times in UI heavy scenes.
Skinned meshes currently can't be instanced, meaning every animated character is a separate draw call. We want to support GPU skinning with instancing so crowds and large numbers of animated entities are significantly cheaper to render.
We don't have a good way of inspecting all resources currently resident on the GPU. We want to be able to quickly glance and filter down what our GPU memory is being used for.
Terrain is currently rendered with one big geometry clipmap mesh. We want to split it up into a level of instanced clipmaps for a simple level of CPU culling, reducing GPU overhead especially in auxiliary views.
For animations that have a lead-in and hold on a pose/loop. Instead of splitting them up and using code to trigger them in time, you can use Loop Points to have a single animation with the lead-in and loop and when that animation is played the lead-in will only be played a single time.
An easy way to import a spritesheet and have it split up automatically into animations without the need for individual images that you would need to import one-by-one in each animation manually