public IEnumerator RemoveAndAddPhysicsMaterialToAnotherBrushMaterial_MaterialStillRegistered()
{
using (ChiselBrushMaterial newBrushMaterial1 = new ChiselBrushMaterial(), newBrushMaterial2 = new ChiselBrushMaterial())
{
var newPhysicsMaterial1 = new PhysicMaterial();
var newPhysicsMaterial2 = new PhysicMaterial();
newBrushMaterial1.PhysicsMaterial = newPhysicsMaterial1;
newBrushMaterial2.PhysicsMaterial = newPhysicsMaterial2;
yield return(null);
ChiselBrushMaterialManager.Update();
Assert.AreEqual(newPhysicsMaterial1, ChiselBrushMaterialManager.GetPhysicsMaterialByInstanceID(newPhysicsMaterial1.GetInstanceID(), false));
Assert.AreEqual(newPhysicsMaterial2, ChiselBrushMaterialManager.GetPhysicsMaterialByInstanceID(newPhysicsMaterial2.GetInstanceID(), false));
Assert.AreEqual(1, ChiselBrushMaterialManager.GetPhysicsMaterialRefCountByInstanceID(newPhysicsMaterial1.GetInstanceID()));
Assert.AreEqual(1, ChiselBrushMaterialManager.GetPhysicsMaterialRefCountByInstanceID(newPhysicsMaterial2.GetInstanceID()));
newBrushMaterial1.PhysicsMaterial = newPhysicsMaterial2;
newBrushMaterial2.PhysicsMaterial = newPhysicsMaterial1;
yield return(null);
ChiselBrushMaterialManager.Update();
Assert.AreEqual(newPhysicsMaterial1, ChiselBrushMaterialManager.GetPhysicsMaterialByInstanceID(newPhysicsMaterial1.GetInstanceID(), false));
Assert.AreEqual(newPhysicsMaterial2, ChiselBrushMaterialManager.GetPhysicsMaterialByInstanceID(newPhysicsMaterial2.GetInstanceID(), false));
Assert.AreEqual(1, ChiselBrushMaterialManager.GetPhysicsMaterialRefCountByInstanceID(newPhysicsMaterial1.GetInstanceID()));
Assert.AreEqual(1, ChiselBrushMaterialManager.GetPhysicsMaterialRefCountByInstanceID(newPhysicsMaterial2.GetInstanceID()));
UnityEngine.Object.DestroyImmediate(newPhysicsMaterial1);
UnityEngine.Object.DestroyImmediate(newPhysicsMaterial2);
}
}
public IEnumerator RemoveAndAddRenderMaterialToAnotherBrushMaterial_MaterialStillRegistered()
{
using (ChiselBrushMaterial newBrushMaterial1 = ChiselBrushMaterial.CreateInstance(), newBrushMaterial2 = ChiselBrushMaterial.CreateInstance())
{
var newRenderMaterial1 = new Material(Shader.Find("Specular"));
var newRenderMaterial2 = new Material(Shader.Find("Specular"));
newBrushMaterial1.RenderMaterial = newRenderMaterial1;
newBrushMaterial2.RenderMaterial = newRenderMaterial2;
yield return(null);
ChiselBrushMaterialManager.Update();
Assert.AreEqual(newRenderMaterial1, ChiselBrushMaterialManager.GetRenderMaterialByInstanceID(newRenderMaterial1.GetInstanceID(), false));
Assert.AreEqual(newRenderMaterial2, ChiselBrushMaterialManager.GetRenderMaterialByInstanceID(newRenderMaterial2.GetInstanceID(), false));
Assert.AreEqual(1, ChiselBrushMaterialManager.GetRenderMaterialRefCountByInstanceID(newRenderMaterial1.GetInstanceID()));
Assert.AreEqual(1, ChiselBrushMaterialManager.GetRenderMaterialRefCountByInstanceID(newRenderMaterial2.GetInstanceID()));
newBrushMaterial1.RenderMaterial = newRenderMaterial2;
newBrushMaterial2.RenderMaterial = newRenderMaterial1;
yield return(null);
ChiselBrushMaterialManager.Update();
Assert.AreEqual(newRenderMaterial1, ChiselBrushMaterialManager.GetRenderMaterialByInstanceID(newRenderMaterial1.GetInstanceID(), false));
Assert.AreEqual(newRenderMaterial2, ChiselBrushMaterialManager.GetRenderMaterialByInstanceID(newRenderMaterial2.GetInstanceID(), false));
Assert.AreEqual(1, ChiselBrushMaterialManager.GetRenderMaterialRefCountByInstanceID(newRenderMaterial1.GetInstanceID()));
Assert.AreEqual(1, ChiselBrushMaterialManager.GetRenderMaterialRefCountByInstanceID(newRenderMaterial2.GetInstanceID()));
UnityEngine.Object.DestroyImmediate(newRenderMaterial1);
UnityEngine.Object.DestroyImmediate(newRenderMaterial2);
}
}
public static void RegisterAllSurfaces(ChiselBrushContainerAsset brushContainerAsset)
{
if (!brushContainerAsset || brushContainerAsset.SubMeshCount == 0)
{
return;
}
foreach (var brushMesh in brushContainerAsset.BrushMeshes)
{
if (brushMesh.polygons == null)
{
continue;
}
foreach (var polygon in brushMesh.polygons)
{
if (polygon.surface == null)
{
continue;
}
if (polygon.surface.brushMaterial == null)
{
polygon.surface.brushMaterial = ChiselBrushMaterial.CreateInstance();
if (polygon.surface.brushMaterial != null)
{
polygon.surface.brushMaterial.LayerUsage = polygon.surface.brushMaterial.LayerUsage;
polygon.surface.brushMaterial.PhysicsMaterial = polygon.surface.brushMaterial.PhysicsMaterial;
polygon.surface.brushMaterial.RenderMaterial = polygon.surface.brushMaterial.RenderMaterial;
}
}
ChiselBrushMaterialManager.Register(polygon.surface.brushMaterial);
}
}
}
public IEnumerator CreateBrushMaterialWithPhysicMaterial_ChangePhysicMaterial_ManagerOnlyKnowsNewMaterial()
{
using (var newBrushMaterial = new ChiselBrushMaterial())
{
var newPhysicsMaterial1 = new PhysicMaterial();
var newPhysicsMaterial2 = new PhysicMaterial();
newBrushMaterial.PhysicsMaterial = newPhysicsMaterial1;
yield return(null);
var foundPhysicsMaterial = ChiselBrushMaterialManager.GetPhysicsMaterialByInstanceID(newPhysicsMaterial2.GetInstanceID(), false);
Assert.AreNotEqual(newPhysicsMaterial1, newPhysicsMaterial2);
Assert.AreEqual(newPhysicsMaterial1, ChiselBrushMaterialManager.GetPhysicsMaterialByInstanceID(newPhysicsMaterial1.GetInstanceID(), false));
Assert.AreEqual(1, ChiselBrushMaterialManager.GetPhysicsMaterialRefCountByInstanceID(newPhysicsMaterial1.GetInstanceID()));
LogAssert.Expect(LogType.Error, new Regex("Could not find"));
Assert.IsNull(foundPhysicsMaterial);
newBrushMaterial.PhysicsMaterial = newPhysicsMaterial2;
yield return(null);
ChiselBrushMaterialManager.Update();
LogAssert.Expect(LogType.Error, new Regex("Could not find"));
Assert.IsNull(ChiselBrushMaterialManager.GetPhysicsMaterialByInstanceID(newPhysicsMaterial1.GetInstanceID(), false));
Assert.AreEqual(newPhysicsMaterial2, ChiselBrushMaterialManager.GetPhysicsMaterialByInstanceID(newPhysicsMaterial2.GetInstanceID(), false));
Assert.AreEqual(1, ChiselBrushMaterialManager.GetPhysicsMaterialRefCountByInstanceID(newPhysicsMaterial2.GetInstanceID()));
UnityEngine.Object.DestroyImmediate(newPhysicsMaterial1);
UnityEngine.Object.DestroyImmediate(newPhysicsMaterial2);
}
}
static readonly List <GeneratedMeshContents> __foundContents = new List <GeneratedMeshContents>(); // static to avoid allocations
public void Update(ChiselModel model, GameObjectState state, GeneratedMeshDescription[] meshDescriptions, int startIndex, int endIndex)
{
bool meshIsModified = false;
// Retrieve the generatedMeshes and its materials, combine them into a single Unity Mesh/Material array
try
{
for (int i = startIndex; i < endIndex; i++)
{
ref var meshDescription = ref meshDescriptions[i];
var generatedMeshContents = model.Node.GetGeneratedMesh(meshDescription);
if (generatedMeshContents == null)
{
continue;
}
if (generatedMeshContents.indices.Length == 0)
{
generatedMeshContents.Dispose();
continue;
}
var renderMaterial = ChiselBrushMaterialManager.GetRenderMaterialByInstanceID(meshDescription.surfaceParameter);
__foundContents.Add(generatedMeshContents);
__foundMaterials.Add(renderMaterial);
}
triangleBrushes.Clear();
if (__foundContents.Count == 0)
{
if (sharedMesh.vertexCount > 0)
{
sharedMesh.Clear(keepVertexLayout: true);
}
}
else
{
sharedMesh.CopyFrom(__foundContents, triangleBrushes);
#if UNITY_EDITOR
ChiselGeneratedComponentManager.SetHasLightmapUVs(sharedMesh, false);
#endif
}
if (renderMaterials != null &&
renderMaterials.Length == __foundMaterials.Count)
{
__foundMaterials.CopyTo(renderMaterials);
}
else
{
renderMaterials = __foundMaterials.ToArray();
}
if (meshFilter.sharedMesh != sharedMesh)
{
meshFilter.sharedMesh = sharedMesh;
meshIsModified = true;
}
meshRenderer.sharedMaterials = renderMaterials;
meshRenderer.enabled = sharedMesh.vertexCount > 0;
}
public IEnumerator CreateBrushMaterial_BrushMaterialIsPartOfManager()
{
using (var newBrushMaterial = new ChiselBrushMaterial())
{
yield return(null);
ChiselBrushMaterialManager.Update();
Assert.True(ChiselBrushMaterialManager.IsRegistered(newBrushMaterial));
}
}
public static void UpdateMaterials(List <ChiselMeshUpdate> meshUpdates, List <ChiselRenderObjectUpdate> objectUpdates, ref VertexBufferContents vertexBufferContents)
{
Profiler.BeginSample("SetTriangleBrushes");
for (int u = 0; u < objectUpdates.Count; u++)
{
var meshUpdate = meshUpdates[u];
var objectUpdate = objectUpdates[u];
var instance = objectUpdate.instance;
var brushIndicesArray = vertexBufferContents.triangleBrushIndices[meshUpdate.contentsIndex].AsArray();
if (instance.triangleBrushes.Length < brushIndicesArray.Length)
{
instance.triangleBrushes = new int[brushIndicesArray.Length];
}
NativeArray <int> .Copy(brushIndicesArray, instance.triangleBrushes, brushIndicesArray.Length);
}
Profiler.EndSample();
Profiler.BeginSample("UpdateMaterials");
for (int u = 0; u < objectUpdates.Count; u++)
{
var meshUpdate = meshUpdates[u];
var objectUpdate = objectUpdates[u];
var instance = objectUpdate.instance;
var contentsIndex = meshUpdate.contentsIndex;
var materialOverride = objectUpdate.materialOverride;
var startIndex = vertexBufferContents.subMeshSections[contentsIndex].startIndex;
var endIndex = vertexBufferContents.subMeshSections[contentsIndex].endIndex;
var desiredCapacity = endIndex - startIndex;
if (instance.renderMaterials == null || instance.renderMaterials.Length != desiredCapacity)
{
instance.renderMaterials = new Material[desiredCapacity];
}
if (materialOverride)
{
for (int i = 0; i < instance.renderMaterials.Length; i++)
{
instance.renderMaterials[i] = materialOverride;
}
}
else
{
for (int i = 0; i < desiredCapacity; i++)
{
var meshDescription = vertexBufferContents.meshDescriptions[startIndex + i];
var renderMaterial = ChiselBrushMaterialManager.GetRenderMaterialByInstanceID(meshDescription.surfaceParameter);
instance.renderMaterials[i] = renderMaterial;
}
}
instance.SetMaterialsIfModified(instance.meshRenderer, instance.renderMaterials);
}
Profiler.EndSample();
}
public IEnumerator CreateBrushMaterial_UnregisterBrushMaterial_BrushMaterialIsNotPartOfManager()
{
using (var newBrushMaterial = ChiselBrushMaterial.CreateInstance())
{
ChiselBrushMaterialManager.Unregister(newBrushMaterial);
yield return(null);
ChiselBrushMaterialManager.Update();
Assert.False(ChiselBrushMaterialManager.IsRegistered(newBrushMaterial));
}
}
public IEnumerator CreateBrushMaterial_Destroy_BrushMaterialIsNotPartOfManager()
{
using (var newBrushMaterial = new ChiselBrushMaterial())
{
yield return(null);
ChiselBrushMaterialManager.Update();
newBrushMaterial.Dispose();
yield return(null);
ChiselBrushMaterialManager.Update();
Assert.False(ChiselBrushMaterialManager.IsRegistered(newBrushMaterial));
}
}
public IEnumerator CreateBrushContainerAsset_Destroy_IsNotPartOfManager()
{
var newBrushContainerAsset = ScriptableObject.CreateInstance <ChiselBrushContainerAsset>();
yield return(null);
ChiselBrushMaterialManager.Update();
UnityEngine.Object.DestroyImmediate(newBrushContainerAsset);
yield return(null);
ChiselBrushContainerAssetManager.Update();
//Assert.False(ChiselBrushContainerAssetManager.IsInUnregisterQueue(newBrushContainerAsset)); // should already be done
Assert.False(ChiselBrushContainerAssetManager.IsRegistered(newBrushContainerAsset));
UnityEngine.Object.DestroyImmediate(newBrushContainerAsset);
}
public IEnumerator CreateBrushMaterialWithPhysicMaterial_ManagerKnowsMaterial()
{
using (var newBrushMaterial = new ChiselBrushMaterial())
{
var newPhysicsMaterial = new PhysicMaterial();
newBrushMaterial.PhysicsMaterial = newPhysicsMaterial;
yield return(null);
ChiselBrushMaterialManager.Update();
Assert.True(ChiselBrushMaterialManager.IsRegistered(newBrushMaterial));
Assert.AreEqual(newPhysicsMaterial, ChiselBrushMaterialManager.GetPhysicsMaterialByInstanceID(newPhysicsMaterial.GetInstanceID(), false));
Assert.AreEqual(1, ChiselBrushMaterialManager.GetPhysicsMaterialRefCountByInstanceID(newPhysicsMaterial.GetInstanceID()));
UnityEngine.Object.DestroyImmediate(newPhysicsMaterial);
}
}
public IEnumerator CreateTwoBrushMaterialsWithSamePhysicsMaterial_RefCountIsTwo()
{
using (ChiselBrushMaterial newBrushMaterial1 = new ChiselBrushMaterial(), newBrushMaterial2 = new ChiselBrushMaterial())
{
var newPhysicsMaterial = new PhysicMaterial();
newBrushMaterial1.PhysicsMaterial = newPhysicsMaterial;
newBrushMaterial2.PhysicsMaterial = newPhysicsMaterial;
yield return(null);
ChiselBrushMaterialManager.Update();
Assert.AreEqual(newPhysicsMaterial, ChiselBrushMaterialManager.GetPhysicsMaterialByInstanceID(newPhysicsMaterial.GetInstanceID(), false));
Assert.AreEqual(2, ChiselBrushMaterialManager.GetPhysicsMaterialRefCountByInstanceID(newPhysicsMaterial.GetInstanceID()));
UnityEngine.Object.DestroyImmediate(newPhysicsMaterial);
}
}
public IEnumerator CreateBrushMaterialWithPhysicMaterial_DestroyBrushMaterial_ManagerDoesNotKnowMaterial()
{
using (var newBrushMaterial = new ChiselBrushMaterial())
{
var newPhysicsMaterial = new PhysicMaterial();
newBrushMaterial.PhysicsMaterial = newPhysicsMaterial;
newBrushMaterial.Dispose();
yield return(null);
ChiselBrushMaterialManager.Update();
LogAssert.Expect(LogType.Error, new Regex("Could not find"));
Assert.IsNull(ChiselBrushMaterialManager.GetPhysicsMaterialByInstanceID(newPhysicsMaterial.GetInstanceID(), false));
UnityEngine.Object.DestroyImmediate(newPhysicsMaterial);
}
}
public IEnumerator CreateBrushMaterialWithPhysicMateriall_RetrieveRenderMaterialWithPhysicsMaterialInstanceID_ReturnsNull()
{
using (var newBrushMaterial = new ChiselBrushMaterial())
{
var newPhysicsMaterial = new PhysicMaterial();
newBrushMaterial.PhysicsMaterial = newPhysicsMaterial;
yield return(null);
ChiselBrushMaterialManager.Update();
Assert.True(ChiselBrushMaterialManager.IsRegistered(newBrushMaterial));
LogAssert.Expect(LogType.Error, new Regex("Trying to use PhysicMaterial with"));
Assert.IsNull(ChiselBrushMaterialManager.GetRenderMaterialByInstanceID(newPhysicsMaterial.GetInstanceID(), false));
UnityEngine.Object.DestroyImmediate(newPhysicsMaterial);
}
}
public static ChiselColliderObjects Create(GameObject container, int surfaceParameter)
{
var physicsMaterial = ChiselBrushMaterialManager.GetPhysicsMaterialByInstanceID(surfaceParameter);
var sharedMesh = new Mesh {
name = ChiselGeneratedObjects.kGeneratedMeshColliderName
};
var meshCollider = container.AddComponent <MeshCollider>();
var colliderObjects = new ChiselColliderObjects
{
surfaceParameter = surfaceParameter,
meshCollider = meshCollider,
physicsMaterial = physicsMaterial,
sharedMesh = sharedMesh
};
colliderObjects.Initialize();
return(colliderObjects);
}
public IEnumerator CreateBrushMaterialWithRenderMaterial_ManagerKnowsMaterial()
{
using (var newBrushMaterial = ChiselBrushMaterial.CreateInstance())
{
var newRenderMaterial = new Material(Shader.Find("Specular"));
newBrushMaterial.RenderMaterial = newRenderMaterial;
yield return(null);
ChiselBrushMaterialManager.Update();
Assert.True(ChiselBrushMaterialManager.IsRegistered(newBrushMaterial));
Assert.AreEqual(newRenderMaterial, ChiselBrushMaterialManager.GetRenderMaterialByInstanceID(newRenderMaterial.GetInstanceID(), false));
Assert.AreEqual(1, ChiselBrushMaterialManager.GetRenderMaterialRefCountByInstanceID(newRenderMaterial.GetInstanceID()));
UnityEngine.Object.DestroyImmediate(newRenderMaterial);
}
}
public IEnumerator CreateTwoBrushMaterialsWithSameRenderMaterial_RefCountIsTwo()
{
using (ChiselBrushMaterial newBrushMaterial1 = ChiselBrushMaterial.CreateInstance(), newBrushMaterial2 = ChiselBrushMaterial.CreateInstance())
{
var newRenderMaterial = new Material(Shader.Find("Specular"));
newBrushMaterial1.RenderMaterial = newRenderMaterial;
newBrushMaterial2.RenderMaterial = newRenderMaterial;
yield return(null);
ChiselBrushMaterialManager.Update();
Assert.AreEqual(newRenderMaterial, ChiselBrushMaterialManager.GetRenderMaterialByInstanceID(newRenderMaterial.GetInstanceID(), false));
Assert.AreEqual(2, ChiselBrushMaterialManager.GetRenderMaterialRefCountByInstanceID(newRenderMaterial.GetInstanceID()));
UnityEngine.Object.DestroyImmediate(newRenderMaterial);
}
}
public IEnumerator CreateTwoBrushMaterialsWithSameRenderMaterial_DestroyBothBrushMaterials_ManagerDoesNotKnowMaterial()
{
using (ChiselBrushMaterial newBrushMaterial1 = new ChiselBrushMaterial(), newBrushMaterial2 = new ChiselBrushMaterial())
{
var newRenderMaterial = new Material(Shader.Find("Specular"));
newBrushMaterial1.RenderMaterial = newRenderMaterial;
newBrushMaterial2.RenderMaterial = newRenderMaterial;
newBrushMaterial1.Dispose();
newBrushMaterial2.Dispose();
yield return(null);
ChiselBrushMaterialManager.Update();
LogAssert.Expect(LogType.Error, new Regex("Could not find"));
Assert.IsNull(ChiselBrushMaterialManager.GetRenderMaterialByInstanceID(newRenderMaterial.GetInstanceID(), false));
UnityEngine.Object.DestroyImmediate(newRenderMaterial);
}
}
public static void UnregisterAllSurfaces(ChiselBrushContainerAsset brushContainerAsset)
{
if (!brushContainerAsset || brushContainerAsset.SubMeshCount == 0)
{
return;
}
foreach (var brushMesh in brushContainerAsset.BrushMeshes)
{
if (brushMesh.polygons == null)
{
continue;
}
foreach (var polygon in brushMesh.polygons)
{
if (polygon.surface == null ||
polygon.surface.brushMaterial == null)
{
continue;
}
ChiselBrushMaterialManager.Unregister(polygon.surface.brushMaterial);
}
}
}
internal void BuildComponents(ChiselModel model,
ModelState modelState,
ChiselGeneratedModelMesh generatedMesh)
{
Material renderMaterial = null;
PhysicMaterial physicsMaterial = null;
if (generatedMesh.meshDescription.surfaceParameter != 0)
{
var type = generatedMesh.meshDescription.meshQuery.LayerParameterIndex;
var parameter = generatedMesh.meshDescription.surfaceParameter;
switch (type)
{
case LayerParameterIndex.LayerParameter1: renderMaterial = ChiselBrushMaterialManager.GetRenderMaterialByInstanceID(parameter); break;
case LayerParameterIndex.LayerParameter2: physicsMaterial = ChiselBrushMaterialManager.GetPhysicsMaterialByInstanceID(parameter); break;
}
}
else
{
var type = generatedMesh.meshDescription.meshQuery.LayerParameterIndex;
switch (type)
{
case LayerParameterIndex.LayerParameter1: renderMaterial = CSGMaterialManager.DefaultMaterial; break;
case LayerParameterIndex.LayerParameter2: physicsMaterial = CSGMaterialManager.DefaultPhysicsMaterial; break;
}
}
if (renderMaterial != null)
{
generatedMesh.renderComponents = null;
List <ChiselRenderComponents> components;
if (modelState.existingRenderComponents.TryGetValue(renderMaterial, out components))
{
while (components.Count > 0)
{
var curComponents = components[0];
components.RemoveAt(0);
if (components.Count == 0)
{
modelState.existingRenderComponents.Remove(renderMaterial);
model.generatedComponents.Remove(curComponents.transform);
}
if (curComponents.meshRenderer && curComponents.meshFilter)
{
generatedMesh.renderComponents = curComponents;
break;
}
}
}
var forceUpdate = UpdateOrCreateRenderComponents(model, modelState, generatedMesh.meshDescription, ref generatedMesh.renderComponents);
if (generatedMesh.renderComponents.meshRenderer.sharedMaterial != renderMaterial)
{
generatedMesh.renderComponents.meshRenderer.sharedMaterial = renderMaterial;
}
if (generatedMesh.renderComponents.meshFilter.sharedMesh != generatedMesh.sharedMesh)
{
generatedMesh.renderComponents.meshFilter.sharedMesh = generatedMesh.sharedMesh;
}
if (generatedMesh.needsUpdate || forceUpdate)
{
#if UNITY_EDITOR
if ((modelState.staticFlags & UnityEditor.StaticEditorFlags.LightmapStatic) == UnityEditor.StaticEditorFlags.LightmapStatic)
{
generatedMesh.renderComponents.meshRenderer.realtimeLightmapIndex = -1;
generatedMesh.renderComponents.meshRenderer.lightmapIndex = -1;
generatedMesh.renderComponents.uvLightmapUpdateTime = Time.realtimeSinceStartup;
haveUVsToUpdate = true;
}
#endif
}
}
else
if (physicsMaterial != null)
{
generatedMesh.colliderComponents = null;
List <ChiselColliderComponents> components;
if (modelState.existingMeshColliders.TryGetValue(physicsMaterial, out components))
{
while (components.Count > 0)
{
var curComponents = components[0];
components.RemoveAt(0);
if (components.Count == 0)
{
modelState.existingMeshColliders.Remove(physicsMaterial);
model.generatedComponents.Remove(curComponents.transform);
}
if (curComponents.meshCollider)
{
generatedMesh.colliderComponents = curComponents;
break;
}
}
}
UpdateOrCreateColliderComponents(model, modelState, generatedMesh.meshDescription, ref generatedMesh.colliderComponents);
if (generatedMesh.colliderComponents.meshCollider.sharedMesh != generatedMesh.sharedMesh)
{
generatedMesh.colliderComponents.meshCollider.sharedMesh = generatedMesh.sharedMesh;
}
if (generatedMesh.colliderComponents.meshCollider.sharedMaterial != physicsMaterial)
{
generatedMesh.colliderComponents.meshCollider.sharedMaterial = physicsMaterial;
}
}
generatedMesh.needsUpdate = false;
}
