NetworkTransform local & world scaling.

[BruceKristelijn]

I noticed the scale synchronisation completely breaking when multiple parents had a scale other than 1,1,1. In the code I see the scale only being set as localScale while the position and rotation differentiatie between local & nonlocal behaviour.

Is this intended? I got soms objects that are WAY too big on my clients using non local scale.

Code:

com.unity.netcode.gameobjects/com.unity.netcode.gameobjects/Components/NetworkTransform.cs

Line 2055 in 2717686

transform.localScale = currentScale;

[NoelStephensUnity]

@BruceKristelijn
The transform has two scale values:

• transform.localScale --> local scale with read/write
• transform.lossyScale --> "world space" scale with read only

With your child NetworkTransforms, how are they parented?
(i.e. are they in-scene placed and pre-parented or are you using the NetworkObject.TrySetParent method)

• If you are using NetworkObject.TrySetParent
  • Pass in false to the second worldPositionStays parameter in order to preserve local space relative values.
  • By default this value is true and when doing the initial synchronization NetworkTransform will use the lossyScale (basically world space scale) for the initial values synchronized on the authoritative side which would indeed make your scale values skewed.
• If you are using in-scene Placed NetworkObjects, then it should automatically detect child NetworkObjects and use the localScale for initial synchronization (which leads me to believe you are using the former TrySetParent method?).

Let me know if disabling worldPositionStays when parenting the children resolves your scale issue?

[BruceKristelijn]

Hi there, so this actually does not happen while changing parents but it happens right after connecting. The scale is set to Vector3(1,1,1) when syncscale is disabled and the localscale on the clients is set to the lossyScale of the server's object.

With parenting like this:

parent1 (Scale: 1,1,1)
parent2 (Scale: 10,10,10)
object (Scale: 1,1,1)

the object seems to get really large on connected clients when inlocalSpace is disabled. I hope this explains my issue a bit more. I don't create issues that often.

I added this image which my help explain the issues I am having on clients.

[NoelStephensUnity]

@BruceKristelijn
Ok, I have a few questions to make sure I understand the issue you are experiencing.

Does the below layout look like your hierarchy?

• parent1 (Scale: 1,1,1)

  • parent2 (Scale: 10,10,10)
    • object (Scale: 1,1,1) --> NetworkTransform.InLocalSpace == false

• If so, how does object get parented under parent2?

  • If by runtime code, are you using the NetworkObject.TrySetParent method?
    • If you do use the NetworkObject.TrySetParent method, do you set the second parameter, worldPositionStays, to false?

The reason why I am asking this is due to this code in NetworkTransform when it is first synchronizing a client:

                var useLossy = NetworkObject.WorldPositionStays() && hasParentNetworkObject;
                var scaleToUse = useLossy ? transform.lossyScale : transform.localScale;

If object is parented under parent2 with the WorldPositionStays value set to true then it will use the lossy scale value when first synchronizing. If you parent object under parent2 with the WorldPositionStays value set to false then it will use the localScale when first synchronizing.

Another Approach:
If your scale never changes during runtime and the NetworkObjects always default to those values where the parent1 is 1 for xyz, parent2 is 10 for xyz, and object is 1 for xyz scale then you can always just disable scale synchronization on the NetworkTransform(s) to avoid the issue as well.

[BruceKristelijn]

@NoelStephensUnity
yes you have the hierarchy part right. And the issue still persists. But it also seemed that on start a size is applied to the client's instantiated object

[NoelStephensUnity]

@BruceKristelijn
What about this portion:

• If so, how does object get parented under parent2?
  • If by runtime code, are you using the NetworkObject.TrySetParent method?
    • If you do use the NetworkObject.TrySetParent method, do you set the second parameter, worldPositionStays, to false?

I went ahead and put together a mini parenting example project that should provide us a starting point to compare how you are parenting your NetworkObjects.
Here is a video of the project running where I have a root parent (in this case it is an in-scene placed Object) and two dynamically spawned objects that I use to parent (Second and Child). Second has a scale of 10 for all axis (it is the plane) and Child is the blue box that defaults to a 1 scale.

Here is a screenshot of the Child being parented under second with the World Position Stays value to set to true:

Note that with this setup it shouldn't matter (from a scale perspective) whether I set World Position Stays to true or false when parenting the Plane under RootParent since its scale is basically Vector3.one. However, how we parent the Child object does matter since the Plane's scale is 10,10,10. In order to preserve the "relative scale to its parent" we make sure to parent Child with World Position Stays set to true. This will result in the Child's scale, when parented under Plane, will become 0.1, 0.1, 0.1 since keeping the "world space/lossy scale" value (i.e. that is really what "World Position Stays does") as 1.0, 1.0, 1.0 under a parent who's scale value is 10, 10, 10 requires the Child's scale to be 0.1, 0.1, 0.1 since the parent's scale is applied to the child.

Here is the project so you can look at how I have it set up and compare that to your project.
ParentingScaleExample.zip

If you think I am missing something crucial about how you are parenting or a difference between the example parenting with scale project and your project, feel free to make modifications, zip up the Assets and Packages folder, and post that updated version here so I can see if there is a bug or if there is something that could be adjusted to resolve your issue.

[NoelStephensUnity]

I am going to be posting a version with NetworkTransform shortly that will provide additional controls to show how you can handle scale issues as well.

[NoelStephensUnity]

@BruceKristelijn
I think I have identified an issue with NetworkTransform and scale during the initial synchronization and will be looking further into this with a PR and a fix. This would be a hot-patch fix.

[NoelStephensUnity]

@BruceKristelijn
Ok, I have identified a region of the NetworkTransform that will require me to reconsider. However, I also put together a NetworkTransformOverride component you can use in place of the default NetworkTransform that will avoid this issue.
(reference names)

With parenting like this:
parent1 (Scale: 1,1,1)
parent2 (Scale: 10,10,10)
object (Scale: 1,1,1) --> you would replace the default NetworkTransform with NetworkTransformOverride

This should resolve your issue if you don't plan on changing the scale of "object" when it is parented under "parent2".
The general idea is that you can "hi-jack" a NetworkTransform on the client side to control what axis are updated and which ones are not (independently from authority). The NetworkTransformOverride component will also assure that when "object" is unparented that its scale is immediately set to the proper lossy scale value (by authority) as part of the issue I discovered, when interpolation is enabled, is that the non-authoritative instances would attempt to interpolate from the localScale to the lossyScale when the parent was removed which would cause a "small to large" visual anomaly.

NetworkTransformParentingScale.zip

When viewing the Cube network prefab in the inspector view, you will see the three additional properties that determine what is synchronized on the non-authoritative side when the NetworkObject is parented:

For the example (relative to your scenario), I basically disable the synchronization of scale when the Cube (i.e. object in your example) is parented under a parent with a scale other than Vector3.one.

ParentingNetworkTransformScale.mp4

This should get you unblocked with the scale issue and provide you with some additional insight on how you can override NetworkTransform to gain further control under specific scenarios.

Will also post here when the parenting/scale issue has been resolved within NetworkTransform itself.