Copy transform at runtime

[cregox]

Who doesn’t need, from time to time, being able to copy a whole object, with all its attributes, into some reserved place for later retrieval? Well, I do.

For transforms, currently I’m using this:

GameObject initialTransformGO = Instantiate(handlingTransform.gameObject) as GameObject;
initialTransformGO.transform.parent = someGameObjectJustToBeSafe;

The problem is when I want to recover what I just copied, later on, I have to do this:

handlingTransform.localPosition = initialTransformGO.transform.localPosition;
handlingTransform.localRotation = initialTransformGO.transform.localRotation;
handlingTransform.localScale = initialTransformGO.transform.localScale;

And I’m not even sure this will cover 100% all cases, since it’s only copying the local (unlike the instantiate, which is copying every little property).

Is there any solution to this yet?

[Bunny83]

Well, you could implement a simple class to save a position / rotation / scale value and add extension methods to the Transform class that saves / loads the state:

// C#
public class StoreTransform
{
    public Vector3 position;
    public Quaternion rotation;
    public Vector3 localScale;
}

public static class TransformSerializationExtension
{
    public static StoreTransform SaveLocal(this Transform aTransform)
    {
        return new StoreTransform()
        {
            position = aTransform.localPosition;
            rotation = aTransform.localRotation;
            localScale = aTransform.localScale;
        };
    }
    public static StoreTransform SaveWorld(this Transform aTransform)
    {
        return new StoreTransform()
        {
            position = aTransform.position;
            rotation = aTransform.rotation;
            localScale = aTransform.localScale;
        };
    }

    public static void LoadLocal(this Transform aTransform, StoreTransform aData)
    {
        aTransform.localPosition = aData.position;
        aTransform.localRotation = aData.rotation;
        aTransform.localScale  = aData.localScale;
    }

    public static void LoadWorld(this Transform aTransform, StoreTransform aData)
    {
        aTransform.position = aData.position;
        aTransform.rotation = aData.rotation;
        aTransform.localScale  = aData.localScale;
    }
}

This is just an example and probably not the best

This extension can be used like this:

//C#
Transform someTransform;

var save = someTransform.SaveWorld();

// [...]

someTransform.LoadWorld(save);

You could also add the information which space the saved values are in to the StoreTransform class and only provide one load function, but i think it’s more flexible this way.

[Steven-Walker]

I don’t believe there is a way to directly copy the entire transform structure, but independently assigning the position, rotation and scale as you are doing should work fine. Depending on the case, it may be better to use world transform values instead of local. If your goal is to have streamlined code, you could write a utility function like:

function CopyTransform(dst : Transform, src : Transform) {
   dst.localPosition = src.localPosition;
   dst.localRotation = src.localRotation;
   dst.localScale = src.localScale;
}

[daniel-laszlo-kovacs]

CODE:

using UnityEngine;

public class StoredTransform
{
    public Vector3      position;
    public Quaternion   rotation;
    public Vector3      localScale;

    public StoredTransform(Transform aTransform, bool world = true)
    {
        position    = world ? aTransform.position : aTransform.localPosition;
        rotation    = world ? aTransform.rotation : aTransform.localRotation;
        localScale  = aTransform.localScale;
    }
 
    public void Load(Transform aTransform, bool world = true)
    {
        if (world)
        {
            aTransform.position        = position;
            aTransform.rotation        = rotation;
        }
        else
        {
            aTransform.localPosition   = position;
            aTransform.localRotation   = rotation;
        }
        aTransform.localScale      = localScale;
    }
 }

EXAMPLE:

//C#
Transform someTransform;
  
var save = new StoredTransform(someTransform);
  
// [...]
  
save.Load(someTransform);

[cregox]

It can’t be done the way I wanted. The Transform class needs a GameObject to exist. I think because it’s a component, not sure. Also, as an object, it just can’t be copied, like we would expect a variable can. Then we’d need a deep copy implementation or something on those lines, and that can get really complex.

Ideally we would expand Transform and implement a Copy method, but it is a sealed class. So, the next best we can do is implement our own transform, which uses Transform. Since its intent is to store its whole data, without needing to create a new game object or separate variable for each parameter, I find it appropriate to call it StoreTransform. And add as many parameters from Transform as needed. I hope this already cover them all, tho.

Usage / Example:

StoreTransform storedTransform = new StoreTransform(transform); // already copied
// toy around with transform
transform.localPosition = Vector3.zero;
// recover data
storedTransform.Make(transform);

Code:

/// 
/// Enable to store a whole transform without the need of a new game object and all handling there.
/// Using the sealed class Transform would just reference instead of copying data.
/// 
public class StoreTransform {
	public Vector3 localPosition;
	public Vector3 position;
	public Quaternion localRotation;
	public Quaternion rotation;
	public Vector3 localScale;
	public void Set (Transform origin) { set(origin); }
	public void set (Transform origin) {
		localPosition = origin.localPosition;
		position = origin.position;
		localRotation = origin.localRotation;
		rotation = origin.rotation;
		localScale = origin.localScale;
	}
	public void Make (Transform destination) {
		destination.localPosition = localPosition;
		destination.position = position;
		destination.localRotation = localRotation;
		destination.rotation = localRotation;
		destination.localScale = localScale;
	}
	public StoreTransform () {}
	public StoreTransform (Transform origin) {
		set(origin);
	}
}

[grfdhfrgtj]

thats how i made a real copy:

i made a entire go because new Transform(); does not exist

GameObject go_B = new GameObject();
go_B.transform.position = mytransform.position;
go_B.transform.rotation = mytransform.rotation;
go_B.transform.scale= mytransform.scale;