How to set nested Translation to world position

Unity Engine
,
1

For a given Translation component that could be in a hierarchy with arbitrary other rotations, scales and translations on its parents, how do I set the Translation.Value so LocalToWorld.Position will be at a given world position?
Multiplying by the inverse of the localToWorld matrix doesn’t compile.

float3 worldPosition = new float3(1, 2, 3);
float4x4 worldToLocal = math.inverse(localToWorld.Value);
translation.Value = math.mul(worldPosition, worldToLocal); // this will not compile, what is the correct notation or solution?
2 Likes
2

It should be float4, use new float4(pos, 1)

2 Likes
3

While that does seem to compile it does not seem to provide a valid local position that can be applied to Translation to effectively set it to a given world position =/

4

Cause you doing it wrong :slight_smile: You mul to LTW and setting Translation directly, but Translation is in parent relation space. You should add your new local pos to current translation value. Example:

public class TransformSystemTest : JobComponentSystem
{
    private EntityQuery _query;

    protected override void OnCreate()
    {
        _query = GetEntityQuery(typeof(LocalToWorld), typeof(Translation));
    }

    protected override JobHandle OnUpdate(JobHandle inputDeps)
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            Debug.Log("Move last child to (1,1,1) in world space");

            var ltw = _query.ToComponentDataArray<LocalToWorld>(Allocator.TempJob);
            var t = _query.ToComponentDataArray<Translation>(Allocator.TempJob);
          
            float4 newWorldPosition = new float4(1, 1, 1, 1);
            float4x4 worldToLocal = math.inverse(ltw[2].Value);
            float3 newLocalPos = t[2].Value + math.mul(worldToLocal, newWorldPosition).xyz;

            var tmp = t[2];
            tmp.Value = newLocalPos;
            t[2] = tmp;

            _query.CopyFromComponentDataArray(t);
          
            ltw.Dispose();
            t.Dispose();
        }
        return inputDeps;
    }
}

https://www.youtube.com/watch?v=D5dW6-quN3g

11 Likes
5

You, sir, are a lifesaver. Thanks so much for taking the time to write that out :slight_smile:
I suppose that for the less mathematically inclined it would be nice to have some utility methods.

I’ll leave the one for position here for posterity:

public static void SetTranslationToWorldPosition(ref Translation translation, [ReadOnly] LocalToWorld localToWorld, [ReadOnly] float3 worldPosition)
{
    translation.Value = translation.Value + math.mul(math.inverse(localToWorld.Value), new float4(worldPosition, 1)).xyz;
}

I don’t suppose I could bother you for a similar method to set the world rotation? I’ve been at it for a while but keep getting cubes jumping around my screen.

2 Likes
6

Rotation is not so easy like that. This is why Unity have complex rotation stuff in current system. Look at Mike (If I remember right it was his talk) talk about transform system and how they work with rotation, composite rotation etc. And read this docs for better understanding https://docs.unity3d.com/Packages/com.unity.entities@0.1/manual/transform_system.html

2 Likes
7

Just an FYI for people who come here looking for a way to sync a non-ECS transform position / rotation to an entity; there is a much easier way of doing it:

EntityManager.AddComponentObject(entity, gameObject.transform);
EntityManager.AddComponentData(entity, new CopyTransformFromGameObject { });
// OR
EntityManager.AddComponentData(entity, new CopyTransformToGameObject { });

There are 3 things to note with this method:

  • You can remove the transform using RemoveComponent.
  • It is possible to assign another non-null transform by calling AddComponentObject() again.
  • The syncing of the transform from the gameObject to the entity seems to be applied directly to the LocalToWorld matrix and the Rotation value is not set as you would expect. Could be a bug they’ll fix but for now it may lead to confusion. You should use the LocalToWorld matrix to get the world position and world rotation from the entity if needed (just use Quaternion.LookRotation(localToWorld.Forward, localToWorld.Up) to get the world rotation)
3 Likes
8

Apparently setting the rotation to a global rotation for a nested entity also requires you to update the LocalToWorld and LocalToParent, but it’s actually pretty straight forward.

I’ve created a solution that seems to work. Simply add a FollowComponent to an entity and define the entity to follow and the following entity’s position / rotation will be set to follow.

Disclaimer: Use at your own peril, have yet to extensively test this. It does not include anything to handle scaling in the hierarchy.

using Unity.Collections;
using Unity.Entities;
using Unity.Mathematics;
using Unity.Transforms;
using UnityEngine;

public struct FollowComponent : IComponentData
{
    public Entity followedEntity;
}

[UpdateInGroup(typeof(LateSimulationSystemGroup))]
public class FollowSystem : ComponentSystem
{
    protected override void OnUpdate()
    {
        ComponentDataFromEntity<LocalToWorld> ltws = GetComponentDataFromEntity<LocalToWorld>(false);
        ComponentDataFromEntity<LocalToParent> ltps = GetComponentDataFromEntity<LocalToParent>(true);

        Entities.WithNone<Parent>().ForEach((
            ref FollowComponent followComponent,
            ref LocalToWorld localToWorld,
            ref Translation translation,
            ref Rotation rotation) =>
        {
            LocalToWorld followedLTW = ltws[followComponent.followedEntity];

            float3 targetWorldPosition = followedLTW.Position;
            quaternion targetWorldRotation = Quaternion.LookRotation(followedLTW.Forward, followedLTW.Up);

            translation.Value = targetWorldPosition;
            rotation.Value = targetWorldRotation;

            localToWorld.Value = new float4x4(targetWorldRotation, targetWorldPosition);
        });

        Entities.ForEach((
            Entity entity,
            ref FollowComponent followComponent,
            ref Parent parent,
            ref LocalToWorld localToWorld,
            ref LocalToParent localToParent,
            ref Translation translation,
            ref Rotation rotation) =>
        {
            LocalToWorld followedLTW = ltws[followComponent.followedEntity];

            float3 targetWorldPosition = followedLTW.Position;
            quaternion targetWorldRotation = Quaternion.LookRotation(followedLTW.Forward, followedLTW.Up);

            LocalToWorld parentLTW = ltws[parent.Value];
            quaternion parentWorldRotation = Quaternion.LookRotation(parentLTW.Forward, parentLTW.Up);
            float3 parentWorldPosition = parentLTW.Position;

            quaternion localRotation = math.mul(targetWorldRotation, math.inverse(parentWorldRotation));
            float3 localPosition = math.mul(math.inverse(parentWorldRotation), targetWorldPosition - parentWorldPosition);

            translation.Value = localPosition;
            rotation.Value = localRotation;

            localToParent.Value = new float4x4(rotation.Value.value, translation.Value);
            localToWorld.Value = new float4x4(targetWorldRotation, targetWorldPosition);
            UpdateChildLocalToWorldsRecursively(entity, localToWorld, ref ltws, ref ltps);
        });
    }

    private void UpdateChildLocalToWorldsRecursively(Entity parentEntity,
        LocalToWorld parentLTW,
        [ReadOnly] ref ComponentDataFromEntity<LocalToWorld> ltws,
        ref ComponentDataFromEntity<LocalToParent> ltps)
    {
        if (!EntityManager.HasComponent<Child>(parentEntity))
        {
            return;
        }

        DynamicBuffer<Child> children = EntityManager.GetBuffer<Child>(parentEntity);
        foreach (Child child in children)
        {
            Entity childEntity = child.Value;
            LocalToParent childLTP = ltps[childEntity];
            LocalToWorld childLTW = ltws[childEntity];
            childLTW.Value = math.mul(parentLTW.Value, childLTP.Value);
            ltws[childEntity] = childLTW;

            UpdateChildLocalToWorldsRecursively(childEntity, childLTW, ref ltws, ref ltps);
        }
    }
}
9 Likes
9

Thanks for the example, you rock!

1 Like
10

this should be in the docs, thanks much dude!

2 Likes
11

What about one for scale? Say I have entity (A) and (B), and I want to parent (B) to (A), but (A) and/or it’s parents might have non-uniform and non-default scales, which automatically skews (B) the moment its parented. Is there a way to use LTW Values to compensate for scale? So that if (B) was 1, 2, 1 in world scale, it would remain so after parented but with new local to parent scale?