Synchronising the size-scaling of 3D models with multi-user capabilities

[BartBlaak]

I finished the below tutorial, which enables synchronisation of 3D model movement and rotation between users. What I need for my project is the ability to synchronise the size-scaling of 3D models as well. I'm honestly already stuck on how to handle this. If anybody has an idea, it would be immensely appreciated. Thank you.

---

Document Details

• ID: c0833304-ecff-860a-aa97-098a7622c432
• Version Independent ID: 404a0f3c-5b29-0e3c-adde-d9c71ada2502
• Content: Sharing object movements with multiple users - Mixed Reality
• Content Source: mixed-reality-docs/mr-dev-docs/develop/unity/tutorials/mr-learning-sharing-04.md
• Product: mixed-reality
• Technology: mr-dev
• GitHub Login: @jessemcculloch
• Microsoft Alias: vinnietieto

[BartBlaak]

Solution: In the GenericNetSync.cs script, the synchronisation of the position and rotation is handled. Add localScale like this:

using Photon.Pun;
using UnityEngine;

namespace MRTK.Tutorials.MultiUserCapabilities
{
    public class GenericNetSync : MonoBehaviourPun, IPunObservable
    {
        [SerializeField] private bool isUser = default;

        private Camera mainCamera;

        private Vector3 networkLocalPosition;
        private Quaternion networkLocalRotation;
        private Vector3 networkLocalScale;

        private Vector3 startingLocalPosition;
        private Quaternion startingLocalRotation;
        private Vector3 startingLocalScale;

        void IPunObservable.OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
        {
            if (stream.IsWriting)
            {
                stream.SendNext(transform.localPosition);
                stream.SendNext(transform.localRotation);
                stream.SendNext(transform.localScale);
            }
            else
            {
                networkLocalPosition = (Vector3) stream.ReceiveNext();
                networkLocalRotation = (Quaternion) stream.ReceiveNext();
                networkLocalScale = (Vector3) stream.ReceiveNext();
            }
        }

        private void Start()
        {
            mainCamera = Camera.main;

            if (isUser)
            {
                if (TableAnchor.Instance != null) transform.parent = FindObjectOfType<TableAnchor>().transform;

                if (photonView.IsMine) GenericNetworkManager.Instance.localUser = photonView;
            }

            var trans = transform;
            startingLocalPosition = trans.localPosition;
            startingLocalRotation = trans.localRotation;
            startingLocalScale = trans.localScale;

            networkLocalPosition = startingLocalPosition;
            networkLocalRotation = startingLocalRotation;
            networkLocalScale = startingLocalScale;
        }

        // private void FixedUpdate()
        private void Update()
        {
            if (!photonView.IsMine)
            {
                var trans = transform;
                trans.localPosition = networkLocalPosition;
                trans.localRotation = networkLocalRotation;
                trans.localScale = networkLocalScale;
            }

            if (photonView.IsMine && isUser)
            {
                var trans = transform;
                var mainCameraTransform = mainCamera.transform;
                trans.position = mainCameraTransform.position;
                trans.rotation = mainCameraTransform.rotation;
                trans.localScale = mainCameraTransform.localScale;
            }
        }
    }
}