+Unity Runtime codeHEADmaster

1 files changed, 721 insertions, 0 deletions

diff --git a/Runtime/Dynamics/DeformableMesh.cpp b/Runtime/Dynamics/DeformableMesh.cpp
new file mode 100644
index 0000000..6fd3de0
--- /dev/null
+++ b/Runtime/Dynamics/DeformableMesh.cpp
@@ -0,0 +1,721 @@
+#include "UnityPrefix.h"
+#include "DeformableMesh.h"
+
+#if ENABLE_CLOTH
+
+#include "Runtime/Graphics/Transform.h"
+#include "Runtime/Filters/Mesh/LodMesh.h"
+#include "Runtime/Serialize/TransferFunctions/SerializeTransfer.h"
+#include "Runtime/BaseClasses/IsPlaying.h"
+#include "PhysicsManager.h"
+#include "External/PhysX/builds/SDKs/Physics/include/NxPhysics.h"
+#include "External/PhysX/builds/SDKs/Cooking/include/NxCooking.h"
+#include "nxmemorystream.h"
+#include "Runtime/Math/Random/Random.h"
+#include "Runtime/Dynamics/ExtractDataFromMesh.h"
+#include "Runtime/Core/Callbacks/GlobalCallbacks.h"
+
+Rand gClothRand (1);
+
+namespace Unity {
+
+Cloth::Cloth (MemLabelId label, ObjectCreationMode mode)
+:	Super(label, mode)
+	, m_FixedUpdateNode(this)	
+	, m_Indices(kMemVertexData)
+	, m_Vertices(kMemVertexData)
+	, m_Normals(kMemVertexData)
+	, m_Tangents(kMemVertexData)
+	, m_UVs(kMemVertexData)
+	, m_UV1s(kMemVertexData)
+	, m_Colors(kMemVertexData)
+	, m_TranslatedVertices(kMemVertexData)
+	, m_TranslatedNormals(kMemVertexData)
+	, m_TranslatedIndices(kMemVertexData)
+{	
+	// configuration
+	m_BendingStiffness = 0.0f;
+	m_StretchingStiffness = 1.0f;
+	m_Damping = 0.0f;
+	m_Thickness = 0.2f;
+	m_UseGravity = true;
+	m_SelfCollision = false;
+	m_ExternalAcceleration = Vector3f::zero;
+	m_RandomAcceleration = Vector3f::zero;
+
+	// state
+	m_Cloth = NULL;
+	m_ClothScene = NULL;
+	m_NumVertices = 0;
+	m_NumIndices = 0;
+	m_NumParentIndices = 0;
+	m_NumVerticesFromPhysX = 0;
+	m_NumIndicesFromPhysX = 0;
+	m_SuspendCount = 0;
+	m_IsSuspended = false;
+	m_NeedToWakeUp = false;
+	m_VerticesForRendering = &m_Vertices;
+	m_NormalsForRendering = &m_Normals;
+	m_IndicesForRendering = &m_Indices;
+	m_NumVerticesForRendering = 0;
+	m_NumIndicesForRendering = 0;
+}
+
+Cloth::~Cloth ()
+{
+	Cleanup();
+}
+
+void Cloth::Reset ()
+{
+	Super::Reset();
+
+	// configuration
+	m_BendingStiffness = 0.0f;
+	m_StretchingStiffness = 1.0f;
+	m_Damping = 0.0f;
+	m_Thickness = 0.2f;
+	m_UseGravity = true;
+	m_SelfCollision = false;
+	m_ExternalAcceleration = Vector3f::zero;
+	m_RandomAcceleration = Vector3f::zero;
+}
+
+void Cloth::Cleanup ()
+{
+	if (m_Cloth)
+	{
+		NxClothMesh* mesh = m_Cloth->getClothMesh();
+		m_ClothScene->releaseCloth(*m_Cloth);
+		GetDynamicsSDK().releaseClothMesh(*mesh);
+		m_Cloth = NULL;
+	}
+	m_NumVertices = 0;
+	m_NumVerticesFromPhysX = 0;
+	m_NumVerticesForRendering = 0;
+	m_NumIndices = 0;
+	m_NumIndicesFromPhysX = 0;
+	m_NumIndicesForRendering = 0;
+}
+
+void Cloth::ProcessMeshForRenderer ()
+{
+	if (m_NumVerticesFromPhysX > m_NumVertices)
+	{
+		int newVertices = m_NumVerticesFromPhysX - m_NumVertices;
+		int size = m_NumVertices;
+		if (m_VertexTranslationTable.size())
+		{
+			size = m_VertexTranslationTable.size();
+			m_VertexTranslationTable.resize_uninitialized(size + newVertices);
+			for (int i=0; i<newVertices; i++)
+				m_VertexTranslationTable[size + i] = m_NumVertices + i;
+		}
+
+		if (!m_UVs.empty())
+		{
+			for (int i=0; i<newVertices; i++)
+				m_UVs[size+i] = m_UVs[m_ParentIndices[m_NumVertices+i]];
+		}
+
+		if (!m_UV1s.empty())
+		{
+			for (int i=0; i<newVertices; i++)
+				m_UV1s[size+i] = m_UV1s[m_ParentIndices[m_NumVertices+i]];
+		}
+		
+		if (!m_Colors.empty())
+		{
+			for (int i=0; i<newVertices; i++)
+				m_Colors[size+i] = m_Colors[m_ParentIndices[m_NumVertices+i]];
+		}
+
+		if (!m_Tangents.empty())
+		{
+			for (int i=0; i<newVertices; i++)
+				m_Tangents[size+i] = m_Tangents[m_ParentIndices[m_NumVertices+i]];
+		}
+
+		m_NumVertices = m_NumVerticesFromPhysX;
+		m_NumVerticesForRendering += newVertices;
+	}
+	if (m_VertexTranslationTable.size())
+	{
+		for (int i=0; i<m_VertexTranslationTable.size(); i++)
+		{
+			int index = m_VertexTranslationTable[i];
+			m_TranslatedVertices[i] = m_Vertices[index];
+			m_TranslatedNormals[i] = m_Normals[index];
+		}
+		if (m_NumIndicesFromPhysX > m_NumIndices)
+		{
+			int size = m_NumIndicesForRendering;
+			int newIndices = m_NumIndicesFromPhysX > m_NumIndices;
+			for (int i=0; i<newIndices; i++)
+			{
+				int newIndex = m_Indices[m_NumIndices + i];
+				if (newIndex < m_NumVertices)
+					m_TranslatedIndices[size + i] = newIndex;
+				else
+					m_TranslatedIndices[size + i] = m_VertexTranslationTable[newIndex];
+			}
+			m_NumIndicesForRendering += newIndices; 
+			m_NumIndices = m_NumIndicesFromPhysX;
+		}
+	}
+	else if (m_NumIndicesFromPhysX > m_NumIndices)
+	{
+		m_NumIndices = m_NumIndicesFromPhysX;
+		m_NumIndicesForRendering = m_NumIndicesFromPhysX;
+	}
+}
+
+bool Cloth::SetupMeshData (bool transformToWorldSpace, bool externalVertexTranlation, int tearMemoryFactor)
+{
+	if (!ExtractDataFromMesh(*m_Mesh, m_Vertices, m_Indices, m_VertexTranslationTable))
+		return false;
+
+    m_NumVertices = m_Vertices.size();
+    m_NumIndices = m_Indices.size();
+    
+	bool vertexTranlationIsNeeded = externalVertexTranlation;
+
+	StrideIterator<Vector2f> uvs = m_Mesh->GetUvBegin(0);
+	StrideIterator<Vector2f> uv1s = m_Mesh->GetUvBegin(1);
+	StrideIterator<ColorRGBA32> colors = m_Mesh->GetColorBegin();
+	if (!vertexTranlationIsNeeded)
+	{
+		// find out if vertex mapping really is needed. If there are UV or color seams, it is.
+		// If there are just some duplicate vertices because the mesh is stripified, then we just use the physX indices instead.
+		for (int i=m_NumVertices; i<m_VertexTranslationTable.size();i++)
+		{
+			if (!uvs.IsNull () && uvs[m_VertexTranslationTable[i]] != uvs[i])
+			{
+				vertexTranlationIsNeeded = true;
+				break;
+			}
+			if (!uv1s.IsNull () && uv1s[m_VertexTranslationTable[i]] != uv1s[i])
+			{
+				vertexTranlationIsNeeded = true;
+				break;
+			}
+			if (!colors.IsNull () && colors[m_VertexTranslationTable[i]] != colors[i])
+			{
+				vertexTranlationIsNeeded = true;				
+				break;
+			}
+			// we don't check for normals and tangents.
+			// normals are regenerated by the cloth code anyways, so split normals are no use here.
+		}
+	}
+
+	if (!vertexTranlationIsNeeded)
+		m_VertexTranslationTable.clear();
+
+	UInt32 maxVertices = std::max (std::max (m_NumVertices, m_NumVerticesFromPhysX), m_NumVertices * tearMemoryFactor);
+	UInt32 maxIndices = std::max (m_NumIndices, m_NumIndices * tearMemoryFactor);
+
+	m_Vertices.resize_uninitialized(maxVertices);
+	m_Normals.resize_uninitialized(maxVertices);
+	m_Indices.resize_initialized(maxIndices, 0);
+	if (tearMemoryFactor>1)
+		m_ParentIndices.resize_initialized(maxVertices, 0);
+	else
+		m_ParentIndices.clear();
+	
+	int maxVerticesForRendering;
+	if (vertexTranlationIsNeeded && !externalVertexTranlation)
+	{
+		Mesh::TemporaryIndexContainer triangles;
+		m_Mesh->GetTriangles(triangles);
+		m_NumIndicesForRendering = triangles.size();
+		m_TranslatedIndices.resize_uninitialized(m_NumIndicesForRendering + m_NumIndices * (tearMemoryFactor-1));
+		for (int i=0; i<m_NumIndicesForRendering; i++)	
+			m_TranslatedIndices[i] = triangles[i];
+		maxVerticesForRendering = m_Mesh->GetVertexCount() + m_NumVertices * (tearMemoryFactor-1);
+		m_TranslatedVertices.resize_uninitialized(maxVerticesForRendering);
+		m_TranslatedNormals.resize_uninitialized(maxVerticesForRendering);
+		m_NumVerticesForRendering = m_Mesh->GetVertexCount();
+		m_VerticesForRendering = &m_TranslatedVertices;
+		m_NormalsForRendering = &m_TranslatedNormals;
+		m_IndicesForRendering = &m_TranslatedIndices;
+	}
+	else 
+	{
+		maxVerticesForRendering = maxVertices;
+		m_TranslatedIndices.clear();
+		m_TranslatedVertices.clear();
+		m_TranslatedNormals.clear();
+		m_VerticesForRendering = &m_Vertices;
+		m_NormalsForRendering = &m_Normals;
+		m_IndicesForRendering = &m_Indices;
+		m_NumVerticesForRendering = m_NumVertices;
+		m_NumIndicesForRendering = m_NumIndices;
+	}
+	
+	if (!m_Mesh->IsAvailable (kShaderChannelNormal))
+	{
+		WarningString("Cloth simulation requires normals!");
+		std::fill (m_Normals.begin (), m_Normals.end (), Vector3f(0,0,0));
+	}
+	else if (vertexTranlationIsNeeded)
+	{
+		StrideIterator<Vector3f> n = m_Mesh->GetNormalBegin ();
+		for (int i=0;i<m_VertexTranslationTable.size();++i, ++n)
+		{
+			int index = m_VertexTranslationTable[i];
+			m_Normals[index] = *n;
+		}
+	}
+	else
+	{
+		strided_copy (m_Mesh->GetNormalBegin (), m_Mesh->GetNormalBegin () + m_NumVertices, m_Normals.begin ());
+	}
+	
+	if (!externalVertexTranlation)
+	{
+		if (m_Mesh->IsAvailable (kShaderChannelTexCoord0))
+		{
+			m_UVs.resize_uninitialized(maxVerticesForRendering);
+			strided_copy (m_Mesh->GetUvBegin (0), m_Mesh->GetUvBegin (0) + m_NumVerticesForRendering, m_UVs.begin ());
+		}
+		else
+			m_UVs.clear();
+
+		if (m_Mesh->IsAvailable (kShaderChannelTexCoord1))
+		{
+			m_UV1s.resize_uninitialized(maxVerticesForRendering);
+			strided_copy (m_Mesh->GetUvBegin (1), m_Mesh->GetUvBegin (1) + m_NumVerticesForRendering, m_UV1s.begin ());
+		}
+		else
+			m_UV1s.clear();
+
+		if (m_Mesh->IsAvailable(kShaderChannelColor))
+		{
+			m_Colors.resize_uninitialized(maxVerticesForRendering);
+			strided_copy (m_Mesh->GetColorBegin (), m_Mesh->GetColorBegin () + m_NumVerticesForRendering, m_Colors.begin ());
+		}
+		else
+			m_Colors.clear();
+
+		if (m_Mesh->IsAvailable(kShaderChannelTangent))
+		{
+			m_Tangents.resize_uninitialized(maxVerticesForRendering);
+			strided_copy (m_Mesh->GetTangentBegin (), m_Mesh->GetTangentBegin () + m_NumVerticesForRendering, m_Tangents.begin ());
+		}
+		else
+			m_Tangents.clear();
+	}
+	
+	if (transformToWorldSpace)
+	{
+		Transform& transform = GetComponent (Transform);
+		TransformPoints3x4(transform.GetLocalToWorldMatrix(), &m_Vertices[0], &m_Vertices[0], m_NumVertices);
+		if (m_Mesh->IsAvailable (kShaderChannelNormal))
+			TransformPoints3x3(transform.GetLocalToWorldMatrixNoScale(), &m_Normals[0], &m_Normals[0], m_NumVertices);	
+		if (m_Mesh->IsAvailable (kShaderChannelTangent))
+		{
+			Matrix4x4f m = transform.GetLocalToWorldMatrixNoScale();
+			for ( int i=0; i<m_NumVertices; i++)
+			{
+				Vector3f tangent = Vector3f(m_Tangents[i].x, m_Tangents[i].y, m_Tangents[i].z);
+				Vector3f normalized = NormalizeSafe (m.MultiplyVector3 (tangent));
+				m_Tangents[i] = Vector4f(normalized.x, normalized.y ,normalized.z, m_Tangents[i].w);
+			}
+		}
+
+		m_NumVerticesFromPhysX = m_NumVertices;
+	}
+	
+	return true;
+}
+
+void Cloth::SetupMeshBuffers (NxMeshData &meshData)
+{
+	meshData.verticesPosBegin = m_Vertices.begin();
+	meshData.verticesNormalBegin = m_Normals.empty() ? NULL : m_Normals.begin();
+	meshData.verticesPosByteStride = sizeof (Vector3f);
+	meshData.verticesNormalByteStride = sizeof (Vector3f);
+	meshData.maxVertices = m_Vertices.size();
+	meshData.numVerticesPtr = (NxU32*)&m_NumVerticesFromPhysX;
+
+	meshData.indicesBegin = &m_Indices[0];
+	meshData.indicesByteStride = sizeof (UInt16);
+	meshData.maxIndices = m_Indices.size();
+	meshData.numIndicesPtr = (NxU32*)&m_NumIndicesFromPhysX;
+	meshData.flags = NX_MDF_16_BIT_INDICES;	
+
+	if (m_ParentIndices.size())
+	{
+		meshData.parentIndicesBegin = &m_ParentIndices[0];
+		meshData.parentIndicesByteStride = sizeof (UInt16);
+		meshData.maxParentIndices = m_ParentIndices.size();
+		meshData.numParentIndicesPtr = (NxU32*)&m_NumParentIndices;
+	}
+}
+
+NxClothMesh *Cloth::CookClothMesh (bool tearable)
+{
+	NxClothMeshDesc clothMeshDesc;
+
+	clothMeshDesc.numVertices = m_NumVertices;
+	clothMeshDesc.numTriangles = m_NumIndices / 3;
+	clothMeshDesc.pointStrideBytes = sizeof (Vector3f);
+	clothMeshDesc.triangleStrideBytes = sizeof (m_Indices[0]) * 3;
+	clothMeshDesc.vertexMassStrideBytes = 0;
+	clothMeshDesc.vertexFlagStrideBytes = 0;
+	clothMeshDesc.points = &m_Vertices[0];
+	clothMeshDesc.triangles = &m_Indices[0];
+	clothMeshDesc.vertexMasses = NULL;
+	clothMeshDesc.vertexFlags = NULL;
+	clothMeshDesc.flags = NX_MF_16_BIT_INDICES;
+
+	if (tearable)
+		clothMeshDesc.flags |= NX_CLOTH_MESH_TEARABLE;
+
+	MemoryStream memoryStream(NULL, 0);	
+	if (!NxCookClothMesh(clothMeshDesc, memoryStream))
+	{
+		ErrorString ("Failed cooking cloth");
+		return NULL;
+	}
+	
+	return GetDynamicsSDK ().createClothMesh(memoryStream);
+}
+
+void Cloth::SetupClothDesc (NxClothDesc &clothDesc, bool tearable)
+{ 
+	SetupMeshBuffers (clothDesc.meshData);
+	clothDesc.collisionGroup = GetGameObject ().GetLayer ();
+	clothDesc.clothMesh = CookClothMesh(tearable);
+	clothDesc.bendingStiffness = m_BendingStiffness;
+	clothDesc.stretchingStiffness = m_StretchingStiffness;
+	clothDesc.dampingCoefficient = m_Damping;
+	clothDesc.thickness = m_Thickness;
+	clothDesc.selfCollisionThickness = m_Thickness;
+	clothDesc.userData = this;
+	if (m_BendingStiffness > 0)
+		clothDesc.flags |= NX_CLF_BENDING;
+	else
+		clothDesc.flags &= ~NX_CLF_BENDING;
+	if (m_Damping > 0)
+		clothDesc.flags |= NX_CLF_DAMPING;
+	else
+		clothDesc.flags &= ~NX_CLF_DAMPING;
+	if (m_UseGravity)
+		clothDesc.flags |= NX_CLF_GRAVITY;
+	else
+		clothDesc.flags &= ~NX_CLF_GRAVITY;
+	if (m_SelfCollision)
+		clothDesc.flags |= NX_CLF_SELFCOLLISION;
+	else
+		clothDesc.flags &= ~NX_CLF_SELFCOLLISION;
+}
+
+void Cloth::Deactivate (DeactivateOperation operation)
+{
+	Super::Deactivate (operation);
+	Cleanup ();
+}
+
+void Cloth::FixedUpdate() 
+{
+	if (m_Cloth)
+	{
+		Vector3f accel = m_ExternalAcceleration+RandomPointInsideCube (gClothRand, m_RandomAcceleration);
+		m_Cloth->setExternalAcceleration((const NxVec3&)accel);
+		if (m_NeedToWakeUp && !m_IsSuspended)
+			m_Cloth->wakeUp();
+	}
+	m_NeedToWakeUp = false;
+}
+
+void Cloth::AddToManager ()
+{
+	GetFixedBehaviourManager().AddBehaviour (m_FixedUpdateNode, -1);
+}
+
+void Cloth::RemoveFromManager ()
+{
+	GetFixedBehaviourManager().RemoveBehaviour (m_FixedUpdateNode);
+}
+
+void Cloth::PauseSimulation ()
+{
+	if (!m_Cloth->isSleeping())
+	{
+		m_IsSuspended = true;
+		m_Cloth->putToSleep();
+	}
+}
+
+void Cloth::ResumeSimulation ()
+{
+	if (m_IsSuspended)
+	{
+		// only wake up the cloth when it becomes visible when it has been set to sleep by the renderer,
+		// not when it has been set to sleep by PhysX.
+		m_IsSuspended = false;
+		m_Cloth->wakeUp();
+	}
+}
+
+void Cloth::AwakeFromLoad(AwakeFromLoadMode awakeMode)
+{
+	if (m_Cloth)
+	{
+		// Apply changed values
+		SetThickness (m_Thickness);
+		SetBendingStiffness (m_BendingStiffness);
+		SetStretchingStiffness (m_StretchingStiffness);
+		SetDamping (m_Damping);
+		SetExternalAcceleration (m_ExternalAcceleration);
+		SetRandomAcceleration (m_RandomAcceleration);
+		SetUseGravity (m_UseGravity);		
+		SetSelfCollision (m_SelfCollision);
+	}
+
+	Super::AwakeFromLoad (awakeMode);
+	if (IsActive ())
+	{
+		if (!m_Cloth)
+			Create ();
+		else
+			m_NeedToWakeUp = true;
+	}
+	else
+		Cleanup ();
+	
+	m_SuspendCount = 0;
+	
+	if(!GetEnabled())
+		SetSuspended(true);
+}
+
+void Cloth::SetSuspended (bool suspended)
+{
+	if (suspended)
+		m_SuspendCount++;
+	else
+		m_SuspendCount--;
+
+	if (m_Cloth)
+	{
+		if (m_SuspendCount)
+			PauseSimulation();
+		else
+			ResumeSimulation();
+	}
+}
+
+void Cloth::SetEnabled (bool enabled)
+{
+	if (enabled != GetEnabled())
+	{
+		Super::SetEnabled(enabled);
+		SetSuspended(!enabled);
+	}
+}
+
+#define ENFORCE_MINEQ(x) {if (value < x) { value = x; ErrorString("value must be greater than or equal to " #x);}}
+#define ENFORCE_MIN(x) {if (value <= x) { value = x; ErrorString("value must be greater than " #x);}}
+#define ENFORCE_MAXEQ(x) {if (value > x) { value = x; ErrorString("value must be smaller than or equal to " #x);}}
+#define ENFORCE_MAX(x) {if (value >= x) { value = x; ErrorString("value must be smaller than " #x);}}
+
+void Cloth::SetBendingStiffness (float value)
+{
+	ENFORCE_MINEQ(0);
+	ENFORCE_MAXEQ(1);
+	if (value != m_BendingStiffness)
+	{
+		m_NeedToWakeUp = true;
+		m_BendingStiffness = value;
+	}
+	if (m_Cloth)
+	{
+		if (value > 0)
+		{
+			m_Cloth->setBendingStiffness(value);
+			m_Cloth->setFlags(m_Cloth->getFlags() | NX_CLF_BENDING);			
+		}	
+		else
+			m_Cloth->setFlags(m_Cloth->getFlags() & ~(NX_CLF_BENDING));			
+	}
+	SetDirty();
+}
+
+void Cloth::SetStretchingStiffness (float value)
+{
+	ENFORCE_MIN(0);
+	ENFORCE_MAXEQ(1);
+	if (value != m_StretchingStiffness)
+	{
+		m_NeedToWakeUp = true;
+		m_StretchingStiffness = value;
+	}
+	if (m_Cloth)
+		m_Cloth->setStretchingStiffness(value);
+	SetDirty();
+}
+
+void Cloth::SetDamping (float value)
+{
+	ENFORCE_MINEQ(0);
+	ENFORCE_MAXEQ(1);
+	if (value != m_Damping)
+	{
+		m_NeedToWakeUp = true;
+		m_Damping = value;
+	}
+	if (m_Cloth)
+	{
+		if (value > 0)
+		{
+			m_Cloth->setDampingCoefficient(value);
+			m_Cloth->setFlags(m_Cloth->getFlags() | NX_CLF_DAMPING);			
+		}
+		else
+			m_Cloth->setFlags(m_Cloth->getFlags() & ~(NX_CLF_DAMPING));			
+	}
+	SetDirty();
+}
+
+void Cloth::SetThickness (float value)
+{
+	ENFORCE_MIN(0);
+
+	if (value != m_Thickness)
+	{
+		m_NeedToWakeUp = true;
+		m_Thickness = value;
+	}
+	if (m_Cloth)
+	{
+		m_Cloth->setThickness(value);
+		m_Cloth->setSelfCollisionThickness(value);
+	}
+	SetDirty();
+}
+
+
+void Cloth::SetUseGravity (bool value)
+{
+	if (value != m_UseGravity)
+	{
+		m_NeedToWakeUp = true;
+		m_UseGravity = value;
+	}
+	if (m_Cloth)
+	{
+		if (value)
+			m_Cloth->setFlags(m_Cloth->getFlags() | NX_CLF_GRAVITY);			
+		else
+			m_Cloth->setFlags(m_Cloth->getFlags() & ~(NX_CLF_GRAVITY));			
+	}	
+	SetDirty();
+}
+
+void Cloth::SetSelfCollision (bool value)
+{
+	if (value != m_SelfCollision)
+	{
+		m_NeedToWakeUp = true;
+		m_SelfCollision = value;
+	}
+	if (m_Cloth)
+	{
+		if (value)
+			m_Cloth->setFlags(m_Cloth->getFlags() | NX_CLF_SELFCOLLISION);			
+		else
+			m_Cloth->setFlags(m_Cloth->getFlags() & ~(NX_CLF_SELFCOLLISION));			
+	}	
+	SetDirty();
+}
+
+void Cloth::SetExternalAcceleration (const Vector3f &value)
+{
+	if (value != m_ExternalAcceleration)
+	{
+		m_NeedToWakeUp = true;
+		m_ExternalAcceleration = value;
+	}
+	SetDirty();
+}
+
+void Cloth::SetRandomAcceleration (const Vector3f &value)
+{
+	if (value != m_RandomAcceleration)
+	{
+		m_NeedToWakeUp = true;
+		m_RandomAcceleration = value;
+	}
+	SetDirty();
+}
+
+template<class TransferFunction>
+void Cloth::Transfer (TransferFunction& transfer) 
+{
+	Super::Transfer (transfer);
+	TRANSFER (m_BendingStiffness);
+	TRANSFER (m_StretchingStiffness);
+	TRANSFER (m_Damping);
+	TRANSFER (m_Thickness);
+	TRANSFER (m_UseGravity);
+	TRANSFER (m_SelfCollision);
+	transfer.Align();
+	TRANSFER (m_ExternalAcceleration);
+	TRANSFER (m_RandomAcceleration);
+}
+
+static void ResetRandSeed ()
+{
+	gClothRand.SetSeed (1);
+}
+	
+void Cloth::InitializeClass ()
+{
+#if UNITY_EDITOR
+	REGISTER_MESSAGE (Cloth, kTransformChanged, TransformChanged, int);
+	REGISTER_MESSAGE_VOID (Cloth, kBecameVisible, BecameVisible);
+	REGISTER_MESSAGE_VOID (Cloth, kBecameInvisible, BecameInvisible);
+#endif	
+	
+	GlobalCallbacks::Get().resetRandomAfterLevelLoad.Register(ResetRandSeed);
+}
+
+void Cloth::CleanupClass ()
+{
+	GlobalCallbacks::Get().resetRandomAfterLevelLoad.Unregister(ResetRandSeed);
+}
+
+#if UNITY_EDITOR
+// When the mesh is updated by Phyics, it acts independently of it's Transform, 
+// simulation is in world coordinates. In the editor, we use this code to allow
+// placement, though.
+void Cloth::TransformChanged( int changeMask )
+{
+	if (!IsWorldPlaying() && IsActive())
+	{
+		Create();
+	}
+}
+
+void Cloth::BecameVisible()
+{
+	if (GetSuspended())
+		SetSuspended (false);
+}
+
+void Cloth::BecameInvisible()
+{
+	SetSuspended (true);
+}
+
+#endif
+}
+
+IMPLEMENT_CLASS_HAS_INIT (Cloth)
+IMPLEMENT_OBJECT_SERIALIZE (Cloth)
+INSTANTIATE_TEMPLATE_TRANSFER (Cloth)
+
+#endif // ENABLE_CLOTH