public static void RecursiveBackwardsAddObjectAndInitialise(Transform transform)
        {
            SceneTrackObject obj = transform.GetComponent <SceneTrackObject>();

            if (obj == null)
            {
                obj = transform.gameObject.AddComponent <SceneTrackObject>();
            }

            if (obj.IsInitializedOrInitializing == false)
            {
                obj.Init();
            }

            Transform parent = transform.parent;

            if (parent != null)
            {
                RecursiveBackwardsAddObjectAndInitialise(parent);
            }
        }
        /// <summary>
        /// Record Transform Changes
        /// </summary>
        /// <param name="forceUpdate">Force the data to be sent to SceneTrack</param>
        private void RecordTransform(bool forceUpdate = false)
        {
            if (overridePose)
            {
                forceUpdate = true;
            }

            // No need to update
            if (!forceUpdate && !_transform.hasChanged && !(_transform.parent != _transformParent))
            {
                return;
            }

            // Check our parent, and reassign and setup it if necessary in SceneTrack
            if (_transform.parent != _transformParent)
            {
                // If we have no parent, make sure to set the handle to 0
                if (_transform.parent == null)
                {
                    _transformParentHandle = 0;
                }
                else
                {
                    // Check if we have a SceneTrackObject on the new parent, if we don't add one
                    _parentSceneTrackObject = _transform.parent.GetComponent <SceneTrackObject>() ??
                                              _transform.parent.gameObject.AddComponent <SceneTrackObject>();

                    // TODO: Possibly add forced init of parent if the order is wrong
                    // ADDED BY ROBIN: Looks like this does happen. Children get initialised before parents.
                    if (_parentSceneTrackObject._initialized == false)
                    {
                        _parentSceneTrackObject.Init();
                    }

                    // Setup some cached references
                    _transformParentHandle = _parentSceneTrackObject.TransformHandle;
                    _transformParent       = _transform.parent;
                }

                // Assign our transform handle inside of SceneTrack as it will have changed
                Object.SetValue_uint32(TransformHandle, Classes.Transform.Parent, _transformParentHandle);
            }

            Vector3    localP, localS;
            Quaternion localR;

            if (overridePose)
            {
                overridePose = false;
                localP       = overridePosePosition;
                localR       = overridePoseRotation;
                localS       = overridePoseScale;
            }
            else
            {
                localP = _transform.localPosition;
                localR = _transform.localRotation;
                localS = _transform.localScale;
            }

            // Update Transform Position, Rotation and Scale.
            Object.SetValue_3_float32(TransformHandle, Classes.Transform.LocalPosition, localP.x, localP.y, localP.z);
            Object.SetValue_4_float32(TransformHandle, Classes.Transform.LocalRotation, localR.x, localR.y, localR.z, localR.w);
            Object.SetValue_3_float32(TransformHandle, Classes.Transform.LocalScale, localS.x, localS.y, localS.z);
        }