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);
}
}
public static BrushMesh CreateBox(Vector3 size, ChiselBrushMaterial brushMaterial)
{
var chiselSurface = new ChiselSurface();
chiselSurface.brushMaterial = brushMaterial;
return(BrushMeshFactory.CreateBox(Vector3.one, in chiselSurface));
}
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 CreateBrushWithBrushContainerAssetWithBrushMaterial_ModifyBrushMaterial_BrushIsDirty()
{
using (var newBrushMaterial = ChiselBrushMaterial.CreateInstance())
{
newBrushMaterial.LayerUsage = LayerUsageFlags.None;
var newBrushContainerAsset = CreateBox(Vector3.one, newBrushMaterial);
var brushGameObject = EditorUtility.CreateGameObjectWithHideFlags("Brush", HideFlags.None);
var brush = brushGameObject.AddComponent <ChiselBrush>();
brush.BrushContainerAsset = newBrushContainerAsset;
yield return(null);
ChiselBrushContainerAssetManager.Update();
ChiselNodeHierarchyManager.Update();
newBrushMaterial.LayerUsage = LayerUsageFlags.Renderable;
ChiselBrushContainerAssetManager.Update();
Assert.IsTrue(brush.Dirty);
yield return(null);
UnityEngine.Object.DestroyImmediate(brushGameObject);
UnityEngine.Object.DestroyImmediate(newBrushContainerAsset);
}
}
public IEnumerator CreateBrushContainerAssetWithBrushMaterial_ModifyBrushMaterialPhysicsMaterial_InstanceChangedEventIsCalled()
{
var newPhysicsMaterial = new PhysicMaterial();
var hasBeenCalled = false;
OnBrushContainerAssetDelegate localDelegate = delegate(ChiselBrushContainerAsset brushContainerAsset)
{ hasBeenCalled = true; };
using (var newBrushMaterial = ChiselBrushMaterial.CreateInstance())
{
newBrushMaterial.PhysicsMaterial = null;
var newBrushContainerAsset = CreateBox(Vector3.one, newBrushMaterial);
yield return(null);
ChiselBrushContainerAssetManager.OnBrushMeshInstanceChanged -= localDelegate;
ChiselBrushContainerAssetManager.OnBrushMeshInstanceChanged += localDelegate;
newBrushMaterial.PhysicsMaterial = newPhysicsMaterial;
yield return(null);
Assert.IsTrue(hasBeenCalled);
ChiselBrushContainerAssetManager.OnBrushMeshInstanceChanged -= localDelegate;
UnityEngine.Object.DestroyImmediate(newBrushContainerAsset);
UnityEngine.Object.DestroyImmediate(newPhysicsMaterial);
}
}
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 CreateBox(Vector3 size, ChiselBrushMaterial brushMaterial, out BrushMesh box)
{
var chiselSurface = new ChiselSurface();
chiselSurface.brushMaterial = brushMaterial;
BrushMeshFactory.CreateBox(Vector3.one, in chiselSurface, out box);
}
static BrushMeshInstance CreateBox(Vector3 size, CSGOperationType operation = CSGOperationType.Additive, Material material = null)
{
if (material == null)
{
material = material2;
}
var brushMaterial = ChiselBrushMaterial.CreateInstance(material);
BrushMesh brushMesh = TestUtility.CreateBox(size, brushMaterial);
return(BrushMeshInstance.Create(brushMesh));
}
public IEnumerator CreateBrushMaterial_BrushMaterialIsPartOfManager()
{
using (var newBrushMaterial = new ChiselBrushMaterial())
{
yield return(null);
ChiselBrushMaterialManager.Update();
Assert.True(ChiselBrushMaterialManager.IsRegistered(newBrushMaterial));
}
}
public IEnumerator CreateBrushMaterial_UnregisterBrushMaterial_BrushMaterialIsNotPartOfManager()
{
using (var newBrushMaterial = ChiselBrushMaterial.CreateInstance())
{
ChiselBrushMaterialManager.Unregister(newBrushMaterial);
yield return(null);
ChiselBrushMaterialManager.Update();
Assert.False(ChiselBrushMaterialManager.IsRegistered(newBrushMaterial));
}
}
public static bool FindBrushMaterials(Vector2 position, out ChiselBrushMaterial[] brushMaterials, out ChiselBrushContainerAsset[] brushContainerAssets, bool selectAllSurfaces)
{
brushMaterials = null;
brushContainerAssets = null;
try
{
CSGTreeBrushIntersection intersection;
if (!PickFirstGameObject(Event.current.mousePosition, out intersection))
{
return(false);
}
var brush = intersection.brush;
var node = CSGNodeHierarchyManager.FindCSGNodeByInstanceID(brush.UserID);
if (!node)
{
return(false);
}
if (selectAllSurfaces)
{
brushContainerAssets = node.GetUsedGeneratedBrushes();
if (brushContainerAssets == null)
{
return(false);
}
brushMaterials = node.GetAllBrushMaterials(brush);
return(true);
}
else
{
var surface = node.FindBrushMaterial(brush, intersection.surfaceID);
if (surface == null)
{
return(false);
}
brushContainerAssets = node.GetUsedGeneratedBrushes();
if (brushContainerAssets == null)
{
return(false);
}
brushMaterials = new ChiselBrushMaterial[] { surface };
return(true);
}
}
catch (Exception ex)
{
Debug.LogException(ex);
return(false);
}
}
public static bool FindBrushMaterials(Vector2 position, out ChiselBrushMaterial[] brushMaterials, out ChiselBrushContainerAsset[] brushContainerAssets, bool selectAllSurfaces)
{
brushMaterials = null;
brushContainerAssets = null;
try
{
ChiselIntersection intersection;
if (!PickFirstGameObject(position, out intersection))
{
return(false);
}
var node = intersection.node;
if (!node)
{
return(false);
}
var brush = intersection.brushIntersection.brush;
if (selectAllSurfaces)
{
brushContainerAssets = node.GetUsedGeneratedBrushes();
if (brushContainerAssets == null)
{
return(false);
}
brushMaterials = node.GetAllBrushMaterials(brush);
return(true);
}
else
{
var surface = node.FindBrushMaterialBySurfaceIndex(brush, intersection.brushIntersection.surfaceIndex);
if (surface == null)
{
return(false);
}
brushContainerAssets = node.GetUsedGeneratedBrushes();
if (brushContainerAssets == null)
{
return(false);
}
brushMaterials = new ChiselBrushMaterial[] { surface };
return(true);
}
}
catch (Exception ex)
{
Debug.LogException(ex);
return(false);
}
}
public static bool IsSelected(ChiselBrushMaterial brushMaterial)
{
var selectedSurfaces = Data.selectedSurfaces;
foreach (var selectedSurface in selectedSurfaces)
{
if (selectedSurface.BrushMaterial == brushMaterial)
{
return(true);
}
}
return(false);
}
public IEnumerator CreateBrushContainerAsset_HasValidInstance()
{
using (var newBrushMaterial = ChiselBrushMaterial.CreateInstance())
{
var newBrushContainerAsset = CreateBox(Vector3.one, newBrushMaterial);
Assert.IsFalse(newBrushContainerAsset.Instances != null && newBrushContainerAsset.Instances[0].Valid);
yield return(null);
ChiselBrushContainerAssetManager.Update();
//Assert.False(ChiselBrushContainerAssetManager.IsInUpdateQueue(newBrushContainerAsset)); // should already be done
Assert.IsTrue(newBrushContainerAsset.Instances != null && newBrushContainerAsset.Instances[0].Valid);
UnityEngine.Object.DestroyImmediate(newBrushContainerAsset);
}
}
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 CreateBrushMaterial_BrushMaterialAddedEventIsCalled()
{
var hasBeenCalled = false;
OnBrushMaterialDelegate localDelegate = delegate(ChiselBrushMaterial brushMaterial)
{ hasBeenCalled = true; };
ChiselBrushMaterialManager.OnBrushMaterialAdded -= localDelegate;
ChiselBrushMaterialManager.OnBrushMaterialAdded += localDelegate;
yield return(null);
using (var newBrushMaterial = new ChiselBrushMaterial())
{
Assert.IsTrue(hasBeenCalled);
ChiselBrushMaterialManager.OnBrushMaterialAdded -= localDelegate;
}
}
public IEnumerator CreateBrushMaterial_ChangeUsageFlag_BrushMaterialChangeEventIsCalled()
{
using (var newBrushMaterial = new ChiselBrushMaterial())
{
var hasBeenCalled = false;
OnBrushMaterialDelegate localDelegate = delegate(ChiselBrushMaterial brushMaterial) { hasBeenCalled = true; };
newBrushMaterial.LayerUsage = LayerUsageFlags.None;
ChiselBrushMaterialManager.OnBrushMaterialChanged -= localDelegate;
ChiselBrushMaterialManager.OnBrushMaterialChanged += localDelegate;
yield return(null);
newBrushMaterial.LayerUsage = LayerUsageFlags.Collidable;
Assert.IsTrue(hasBeenCalled);
ChiselBrushMaterialManager.OnBrushMaterialChanged -= localDelegate;
}
}
public static ChiselBrushContainerAsset CreateBox(Vector3 size, ChiselBrushMaterial material)
{
var boxDefinition = new ChiselBoxDefinition()
{
bounds = new Bounds(Vector3.zero, size),
surfaceDefinition = new ChiselSurfaceDefinition()
{
surfaces = new ChiselSurface[]
{
new ChiselSurface()
{
brushMaterial = material, surfaceDescription = SurfaceDescription.Default
},
new ChiselSurface()
{
brushMaterial = material, surfaceDescription = SurfaceDescription.Default
},
new ChiselSurface()
{
brushMaterial = material, surfaceDescription = SurfaceDescription.Default
},
new ChiselSurface()
{
brushMaterial = material, surfaceDescription = SurfaceDescription.Default
},
new ChiselSurface()
{
brushMaterial = material, surfaceDescription = SurfaceDescription.Default
},
new ChiselSurface()
{
brushMaterial = material, surfaceDescription = SurfaceDescription.Default
}
}
}
};
boxDefinition.Validate();
var brushContainerAsset = ChiselBrushContainerAsset.Create("Box");
brushContainerAsset.Generate(boxDefinition);
return(brushContainerAsset);
}
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 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 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 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 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 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 CreateBrushContainerAsset_Unregister_DoesNotHaveValidInstance()
{
using (var newBrushMaterial = ChiselBrushMaterial.CreateInstance())
{
var newBrushContainerAsset = CreateBox(Vector3.one, newBrushMaterial);
Assert.IsFalse(newBrushContainerAsset.Instances != null && newBrushContainerAsset.Instances[0].Valid);
yield return(null);
ChiselBrushContainerAssetManager.Update();
ChiselBrushContainerAssetManager.Unregister(newBrushContainerAsset);
yield return(null);
ChiselBrushContainerAssetManager.Update();
//Assert.False(ChiselBrushContainerAssetManager.IsInUpdateQueue(newBrushContainerAsset)); // should already be done
Assert.IsFalse(newBrushContainerAsset.Instances != null && newBrushContainerAsset.Instances[0].Valid);
}
}
static void OnChiselBrushMaterialRemoved(ChiselBrushMaterial brushMaterial)
{
HashSet <ChiselBrushContainerAsset> brushContainerAssets;
if (surfaceBrushMeshes.TryGetValue(brushMaterial, out brushContainerAssets))
{
foreach (var brushContainerAsset in brushContainerAssets)
{
if (brushMeshSurfaces.TryGetValue(brushContainerAsset, out HashSet <ChiselBrushMaterial> uniqueSurfaces))
{
uniqueSurfaces.Remove(brushMaterial);
if (brushContainerAsset)
{
updateQueue.Add(brushContainerAsset);
}
}
}
}
surfaceBrushMeshes.Remove(brushMaterial);
}
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 IEnumerator CreateBrushMaterial_ChangeRenderMaterial_BrushMaterialChangeEventIsCalled()
{
using (var newBrushMaterial = ChiselBrushMaterial.CreateInstance())
{
var newRenderMaterial = new Material(Shader.Find("Specular"));
var hasBeenCalled = false;
OnBrushMaterialDelegate localDelegate = delegate(ChiselBrushMaterial brushMaterial)
{ hasBeenCalled = true; };
newBrushMaterial.RenderMaterial = null;
ChiselBrushMaterialManager.OnBrushMaterialChanged -= localDelegate;
ChiselBrushMaterialManager.OnBrushMaterialChanged += localDelegate;
yield return(null);
newBrushMaterial.RenderMaterial = newRenderMaterial;
Assert.IsTrue(hasBeenCalled);
ChiselBrushMaterialManager.OnBrushMaterialChanged -= localDelegate;
UnityEngine.Object.DestroyImmediate(newRenderMaterial);
}
}
public IEnumerator CreateBrushMaterial_ChangePhysicsMaterial_BrushMaterialChangeEventIsCalled()
{
using (var newBrushMaterial = new ChiselBrushMaterial())
{
var newPhysicsMaterial = new PhysicMaterial();
var hasBeenCalled = false;
OnBrushMaterialDelegate localDelegate = delegate(ChiselBrushMaterial brushMaterial)
{ hasBeenCalled = true; };
newBrushMaterial.PhysicsMaterial = null;
ChiselBrushMaterialManager.OnBrushMaterialChanged -= localDelegate;
ChiselBrushMaterialManager.OnBrushMaterialChanged += localDelegate;
yield return(null);
newBrushMaterial.PhysicsMaterial = newPhysicsMaterial;
Assert.IsTrue(hasBeenCalled);
ChiselBrushMaterialManager.OnBrushMaterialChanged -= localDelegate;
UnityEngine.Object.DestroyImmediate(newPhysicsMaterial);
}
}
