Change vertex position not working?

There are other things going on in the code but this part doesnt seem to be working. I am trying to get the vertex positions, rotate the object, then tell it to have its verts where it was previously, even though the rotation has been changed.

verts = theMesh.vertices;
theMesh.transform.localRotation = Quaternion.Euler(0,0,0);
theMesh.vertices= verts;

I use this handy script I found online in all my projects to copy any kind of data.

using System;
using System.Reflection;//for copying objects
using System.Linq;//for string[].Contains()
using UnityEngine;//for print

public class CopyData {
	
	/// <summary>
	/// Copies the data of one object to another. The target object gets properties of the first. 
	/// Any matching properties (by name) are written to the target.
	/// </summary>
	/// <param name="source">The source object to copy from</param>
	/// <param name="target">The target object to copy to</param>
	public static void CopyObjectData(object source, object target)
	{
		CopyObjectData(source, target, String.Empty, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
	}
	
	/// <summary>
	/// Copies the data of one object to another. The target object gets properties of the first. 
	/// Any matching properties (by name) are written to the target.
	/// </summary>
	/// <param name="source">The source object to copy from</param>
	/// <param name="target">The target object to copy to</param>
	/// <param name="excludedProperties">A comma delimited list of properties that should not be copied</param>
	/// <param name="memberAccess">Reflection binding access</param>
	public static void CopyObjectData(object source, object target, string excludedProperties, BindingFlags memberAccess)
	{
		string[] excluded = null;
		if (!string.IsNullOrEmpty(excludedProperties))
		{
			excluded = excludedProperties.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries);
		}
		
		MemberInfo[] miT = target.GetType().GetMembers(memberAccess);

		foreach (MemberInfo Field in miT)
		{
			string name = Field.Name;
			
			// Skip over excluded properties
			if (string.IsNullOrEmpty(excludedProperties) == false
			    && excluded.Contains(name))
			{
				continue;
			}
			
			
			if (Field.MemberType == MemberTypes.Field)
			{
				FieldInfo sourcefield = source.GetType().GetField(name);
				if (sourcefield == null) { continue; }
				
				object SourceValue = sourcefield.GetValue(source);
				((FieldInfo)Field).SetValue(target, SourceValue);
			}

			else if (Field.MemberType == MemberTypes.Property)
			{
				PropertyInfo piTarget = Field as PropertyInfo;
				PropertyInfo sourceField = source.GetType().GetProperty(name, memberAccess);
				if (sourceField == null) { continue; }
				
				if (piTarget.CanWrite && sourceField.CanRead)
				{
					object targetValue = piTarget.GetValue(target, null);
					object sourceValue = sourceField.GetValue(source, null);
					
					if (sourceValue == null) { continue; }
					
					if (sourceField.PropertyType.IsArray
					    && piTarget.PropertyType.IsArray
					    && sourceValue != null ) 
					{
						CopyArray(source, target, memberAccess, piTarget, sourceField, sourceValue);
					}
					else
					{
						CopySingleData(source, target, memberAccess, piTarget, sourceField, targetValue, sourceValue);
					}
				}
			}

		}
	}
	
	private static void CopySingleData(object source, object target, BindingFlags memberAccess, PropertyInfo piTarget, PropertyInfo sourceField, object targetValue, object sourceValue)
	{
		//instantiate target if needed
		if (targetValue == null
		    && piTarget.PropertyType.IsValueType == false
		    && piTarget.PropertyType != typeof(string))
		{
			if (piTarget.PropertyType.IsArray)
			{
				targetValue = Activator.CreateInstance(piTarget.PropertyType.GetElementType());
			}
			else
			{
				targetValue = Activator.CreateInstance(piTarget.PropertyType);
			}
		}
		
		if (piTarget.PropertyType.IsValueType == false
		    && piTarget.PropertyType != typeof(string))
		{
			CopyObjectData(sourceValue, targetValue, "", memberAccess);
			piTarget.SetValue(target, targetValue, null);
		}
		else
		{
			if (piTarget.PropertyType.FullName == sourceField.PropertyType.FullName)
			{
				object tempSourceValue = sourceField.GetValue(source, null);
				piTarget.SetValue(target, tempSourceValue, null);
			}
			else
			{
				CopyObjectData(piTarget, target, "", memberAccess);
			}
		}
	}
	
	private static void CopyArray(object source, object target, BindingFlags memberAccess, PropertyInfo piTarget, PropertyInfo sourceField, object sourceValue)
	{
		int sourceLength = (int)sourceValue.GetType().InvokeMember("Length", BindingFlags.GetProperty, null, sourceValue, null);
		Array targetArray = Array.CreateInstance(piTarget.PropertyType.GetElementType(), sourceLength);
		Array array = (Array)sourceField.GetValue(source, null);
		
		for (int i = 0; i < array.Length; i++)
		{
			object o = array.GetValue(i);
			object tempTarget = Activator.CreateInstance(piTarget.PropertyType.GetElementType());
			CopyObjectData(o, tempTarget, "", memberAccess);
			targetArray.SetValue(tempTarget, i);
		}
		piTarget.SetValue(target, targetArray, null);
	}
}

Vertices are defined in local space. So the rotation of the object is irrelevant for the vertex data.

What you have to do is:

  • transform your vertices into worldspace before you rotate your object
  • rotate your object
  • transform the vertices back into local space

Example:

 verts = theMesh.vertices;
 for (int i = 0; i < verts.Length; i++)
     verts _= theMesh.transform.TransformPoint(verts*);*_

theMesh.transform.localRotation = Quaternion.Euler(0,0,0);
for (int i = 0; i < verts.Length; i++)
verts = theMesh.transform.InverseTransformPoint(verts*);*
theMesh.vertices = verts;
Note: your code seems a bit strange. What exactly is “theMesh”? If it’s the actual Mesh instance, you can’t get a “transform” from it since it’s just a Mesh and not a GameObject. If it’s actually a GameObject or MeshFilter you would have to use the mesh property to access the mesh.