Best practice for update hierarchy's transform?

[vkensou]

I am using Unity. Trying to update hierarchy's transform. But my implement is too slow. Update 5000 entity need almost 1.8ms. a plain Update QuerySystem only need 0.6ms.
maybe the random access to Entity and TryGetComponent slow down it.

Can anyone provide suggestions?

my code like:
components:

// Position, Rotation, Scale3 like friflo's predefined Position, Rotation, Scale3, but is Unity's version.
public struct Position : IComponent, IEquatable<Position>
{
    [Ignore]
    [FieldOffset(0)] public UnityEngine.Vector3 value;
    [FieldOffset(0)] public float x;
    [FieldOffset(4)] public float y;
    [FieldOffset(8)] public float z;
}
public struct Rotation : IComponent, IEquatable<Rotation>
{
    [Ignore]
    [FieldOffset(0)] public Quaternion value;  // 16
    [FieldOffset(0)] public float x;      // (4)
    [FieldOffset(4)] public float y;      // (4)
    [FieldOffset(8)] public float z;      // (4)
    [FieldOffset(12)] public float w;      // (4)
}
public struct Scale3 : IComponent, IEquatable<Scale3>
{
    [Ignore]
    [FieldOffset(0)] public UnityEngine.Vector3 value;  // 12
    [FieldOffset(0)] public float x;      // (4)
    [FieldOffset(4)] public float y;      // (4)
    [FieldOffset(8)] public float z;      // (4)
}
public struct Transform : IComponent
{
    [Ignore]
    [FieldOffset(0)] public UnityEngine.Matrix4x4 value;  // 64
}
public struct LocalTransform : Friflo.Engine.ECS.IComponent
{
    public UnityEngine.Matrix4x4 matrix;
}

systems of update hierarchy's transform:

public class TransformSystem : SoloQuerySystem
{
    protected override void Update(Entity entity)
    {
        if (entity.Parent.IsNull)
        {
            UpdateEntityTransform(CommandBuffer, entity, Matrix4x4.identity);
        }
    }

    static void UpdateEntityTransform(CommandBuffer CommandBuffer, Entity entity, Matrix4x4 parentLocalToWorld)
    {
        if (entity.HasComponent<Friflo.Engine.Unity.Transform>())
        {
            ref var transform = ref entity.GetComponent<Friflo.Engine.Unity.Transform>();
            if (entity.TryGetComponent<LocalTransform>(out var localTransform))
            {
                transform.value = parentLocalToWorld * localTransform.matrix;
                parentLocalToWorld = transform.value;
            }
            else
            {
                transform.value = parentLocalToWorld;
            }    
        }

        foreach (var child in entity.ChildEntities)
        {
            UpdateEntityTransform(CommandBuffer,child, parentLocalToWorld);
        }
    }
}

public class TransformWithLocalTransformSystem : SoloQuerySystem<Position, Rotation, LocalTransform>
{
    protected override void Update(ref Position position, ref Rotation rotation, ref LocalTransform localTransform, int entityId)
    {
        localTransform.matrix = Matrix4x4.TRS(position.value, rotation.value, Vector3.one);
    }
}

system of plain update:

public class TransformSystem : SoloQuerySystem<Position, Rotation, Friflo.Engine.Unity.Transform>
{
    protected override void Update(ref Position position, ref Rotation rotation, ref Friflo.Engine.Unity.Transform transform, int entityId)
    {
        transform.value = Matrix4x4.TRS(position.value, rotation.value, Vector3.one);
    }
}

[friflo]

I would do a measurement with a modified version of TransformSystem and TransformWithLocalTransformSystem.
In those classes comment out all matrix operations.
So you can see the pure cost of iteration / traversing. Which are

• HasComponent<>()
• GetComponent<>()
• TryGetComponent<>()
• foreach (var child in entity.ChildEntities)

By this you can compare this execution time with the 1.8 ms you mentioned above.

[vkensou]

I test it again. With Matrix, it is TransformWithLocalTransformSystem (0.2ms) + TransformSystem (1.5ms).
Without Matrix calc, the time is: TransformWithLocalTransformSystem (0.07ms) + TransformSystem (1.3ms).

TransformWithLocalTransformSystem query 2788 entities, TransformSystem query 5487 entities.

I build friflo with Release mode, and use these dll in Unity Editor. And Unity Editor switch to Release Mode.
Unity version: 2022.3.36, Windows 10

new code :

public class TransformSystem : SoloQuerySystem
{
    protected override void Update(Entity entity)
    {
        if (entity.Parent.IsNull)
        {
            UpdateEntityTransform(CommandBuffer, entity, Matrix4x4.identity);
        }
    }

    static void UpdateEntityTransform(CommandBuffer CommandBuffer, Entity entity, Matrix4x4 parentLocalToWorld)
    {
        if (entity.HasComponent<Friflo.Engine.Unity.Transform>())
        {
            ref var transform = ref entity.GetComponent<Friflo.Engine.Unity.Transform>();
             if (entity.TryGetComponent<LocalTransform>(out var localTransform))
            {
                transform.value = Matrix4x4.identity;
                parentLocalToWorld = transform.value;
            }
            else
            {
                transform.value = parentLocalToWorld;
            }
        }

        foreach (var child in entity.ChildEntities)
        {
            UpdateEntityTransform(CommandBuffer, child, parentLocalToWorld);
        }
    }
}

public class TransformWithLocalTransformSystem : SoloQuerySystem<Position, Rotation, LocalTransform>
{
    protected override void Update(ref Position position, ref Rotation rotation, ref LocalTransform localTransform, int entityId)
    {
        localTransform.matrix = Matrix4x4.identity;
    }
}

[friflo]

The the matrix multiplications are not the bottleneck.
The performance problem when traversing a hierarchy (from the root) is the the memory is accessed randomly.

In this case the benefits of an ECS cannot be applied. The performance gain of an ECS query is the access pattern of continuous memory.

When traversing a entity hierarchy this approach is not possible.
Its a typical performance problem in game development I see when you google it. ("performance transform matrices scene tree".

Here some links but there are much more
https://alexsabourindev.wordpress.com/2019/04/14/creating-an-optimized-transform-hierarchy/
https://thegamedev.guru/unity-performance/scene-hierarchy-catch-that-performance-thief-part-2/

An approach to optimize this is to avoid traversing the whole tree every frame.
So only those sub trees should be updated when something changes their Transform.
E.g. by adding a dirty flag to the Transform. In this case the dirty flag need to be set to all its parents.

This approach is not applicable if the relative position/rotation/scale of every entity changes every frame.
But I don't know you use-case.

[friflo]

1.6 ms for 5000 entities looked as a very high execution time.
So I wrote a small performance test and run it in .NET 8 / Release.

https://github.com/friflo/Friflo.Engine.ECS/blob/main/src/Tests/ECS/Github/Test_GitHub_44.cs

The result:

10,000 iterations traversing 6111 entities: 1.2 sec => 0.12 ms for one iteration.

Some remarks:

• Unity uses Mono for execution, which is significant slower than .NET CLR.
  You may run the same test in Unity for comparison.
• If the 1.6 ms were measured while the Unity > Profiler was active the execution is slower.
  Especially if "Deep Profile" is enabled.
• An optimization approach.
  If possible traverse the sub trees only if something has changed which require an update of the transformation matrices within a sub tree.

[vkensou]

On my computer, this test 10000 iterations use 1.5s.
But this test on Unity Editor Release Mode use 16s. Mono is really toooo slow. It seems that I need to change my design.