public void Destroy()
{
if (colliders != null)
{
foreach (var collider in colliders)
{
if (collider != null)
{
collider.Destroy();
}
}
colliders = null;
}
if (renderables != null)
{
foreach (var renderable in renderables)
{
if (renderable != null)
{
renderable.Destroy();
}
}
renderables = null;
}
ChiselObjectUtility.SafeDestroy(colliderContainer, ignoreHierarchyEvents: true);
ChiselObjectUtility.SafeDestroy(generatedDataContainer, ignoreHierarchyEvents: true);
generatedDataContainer = null;
colliderContainer = null;
}
public void Destroy()
{
ChiselObjectUtility.SafeDestroy(meshCollider);
ChiselObjectUtility.SafeDestroy(sharedMesh);
sharedMesh = null;
meshCollider = null;
physicsMaterial = null;
}
internal void DestroyAllRegisteredGeneratedComponentsInModel(ChiselModel model)
{
GameObject modelGameObject = null;
if (model)
{
modelGameObject = model.gameObject;
}
__uniqueGameObjects.Clear();
foreach (var components in model.generatedRenderComponents.Values)
{
foreach (var component in components)
{
if (component == null)
{
continue;
}
if (component.gameObject)
{
var gameObject = component.gameObject;
if (gameObject != modelGameObject)
{
__uniqueGameObjects.Add(gameObject);
}
}
}
}
foreach (var components in model.generatedMeshColliders.Values)
{
foreach (var component in components)
{
if (component == null)
{
continue;
}
if (component.gameObject)
{
var gameObject = component.gameObject;
if (gameObject != modelGameObject)
{
__uniqueGameObjects.Add(gameObject);
}
}
}
}
foreach (var gameObject in __uniqueGameObjects)
{
ChiselObjectUtility.SafeDestroy(gameObject);
}
__uniqueGameObjects.Clear();
model.generatedRenderComponents.Clear();
model.generatedMeshColliders.Clear();
model.generatedComponents.Clear();
}
private void RemoveContainerGameObject(ChiselModel model)
{
if (model.GeneratedDataTransform)
{
model.GeneratedDataContainer.hideFlags = HideFlags.None;
model.GeneratedDataTransform.hideFlags = HideFlags.None;
CSGNodeHierarchyManager.ignoreNextChildrenChanged = true;
ChiselObjectUtility.SafeDestroy(model.GeneratedDataContainer);
CSGNodeHierarchyManager.ignoreNextChildrenChanged = false;
model.GeneratedDataContainer = null;
model.GeneratedDataTransform = null;
}
}
public void Destroy()
{
#if UNITY_EDITOR
ChiselObjectUtility.SafeDestroy(partialMesh);
partialMesh = null;
#endif
ChiselObjectUtility.SafeDestroy(sharedMesh);
ChiselObjectUtility.SafeDestroy(container, ignoreHierarchyEvents: true);
container = null;
sharedMesh = null;
meshFilter = null;
meshRenderer = null;
renderMaterials = null;
}
public static ChiselModelGeneratedObjects Create(ChiselModel model)
{
// Make sure there's not a dangling container out there from a previous version
var existingContainer = model.FindChildByName(kGeneratedContainerName);
ChiselObjectUtility.SafeDestroy(existingContainer, ignoreHierarchyEvents: true);
var modelState = GameObjectState.Create(model);
var parent = model.transform;
var container = ChiselObjectUtility.CreateGameObject(kGeneratedContainerName, parent, modelState);
var containerTransform = container.transform;
var colliderContainer = ChiselObjectUtility.CreateGameObject(kGeneratedMeshColliderName, containerTransform, modelState);
Debug.Assert((int)LayerUsageFlags.Renderable == 1);
Debug.Assert((int)LayerUsageFlags.CastShadows == 2);
Debug.Assert((int)LayerUsageFlags.ReceiveShadows == 4);
Debug.Assert((int)LayerUsageFlags.RenderReceiveCastShadows == (1 | 2 | 4));
var renderables = new ChiselRenderObjects[]
{
null,//ChiselRenderObjects Create(kGeneratedMeshRendererNames[0], containerTransform, modelState, LayerUsageFlags.None),
ChiselRenderObjects.Create(kGeneratedMeshRendererNames[1], containerTransform, modelState, LayerUsageFlags.Renderable),
ChiselRenderObjects.Create(kGeneratedMeshRendererNames[2], containerTransform, modelState, LayerUsageFlags.CastShadows),
ChiselRenderObjects.Create(kGeneratedMeshRendererNames[3], containerTransform, modelState, LayerUsageFlags.Renderable | LayerUsageFlags.CastShadows),
null, //ChiselRenderObjects.Create(kGeneratedMeshRendererNames[4], containerTransform, modelState, LayerUsageFlags.ReceiveShadows),
ChiselRenderObjects.Create(kGeneratedMeshRendererNames[5], containerTransform, modelState, LayerUsageFlags.Renderable | LayerUsageFlags.ReceiveShadows),
null, //ChiselRenderObjects.Create(kGeneratedMeshRendererNames[6], containerTransform, modelState, LayerUsageFlags.CastShadows | LayerUsageFlags.ReceiveShadows),
ChiselRenderObjects.Create(kGeneratedMeshRendererNames[7], containerTransform, modelState, LayerUsageFlags.Renderable | LayerUsageFlags.CastShadows | LayerUsageFlags.ReceiveShadows),
};
var meshRenderers = new MeshRenderer[]
{
renderables[1].meshRenderer,
renderables[2].meshRenderer,
renderables[3].meshRenderer,
renderables[5].meshRenderer,
renderables[7].meshRenderer
};
return(new ChiselModelGeneratedObjects
{
generatedDataContainer = container,
colliderContainer = colliderContainer,
colliders = new ChiselColliderObjects[0],
renderables = renderables,
meshRenderers = meshRenderers
});
}
// Destroy all Unity Meshes that aren't used and haven't been recycled
public void DestroyNonRecycledUnusedUnityMeshes()
{
// Remove our garbage
for (int i = 0; i < garbage.Count; i++)
{
refCountedMeshes.Remove(garbage[i]);
}
garbage.Clear();
// Make sure we destroy the leftover meshes
for (int i = 0; i < garbageMeshes.Count; i++)
{
ChiselObjectUtility.SafeDestroy(garbageMeshes[i]);
}
garbageMeshes.Clear();
}
public static void Reset()
{
Clear();
var usedContainers = new HashSet <ChiselBrushContainerAsset>();
var chiselNodes = Resources.FindObjectsOfTypeAll <ChiselNode>();
foreach (var chiselNode in chiselNodes)
{
var usedAssets = chiselNode.GetUsedGeneratedBrushes();
if (usedAssets == null)
{
continue;
}
foreach (var asset in usedAssets)
{
usedContainers.Add(asset);
}
}
var brushContainerAssets = Resources.FindObjectsOfTypeAll <ChiselBrushContainerAsset>();
foreach (var brushContainerAsset in brushContainerAssets)
{
if (!usedContainers.Contains(brushContainerAsset))
{
#if UNITY_EDITOR
var path = UnityEditor.AssetDatabase.GetAssetPath(brushContainerAsset);
if (string.IsNullOrEmpty(path))
#endif
{
ChiselObjectUtility.SafeDestroy(brushContainerAsset);
continue;
}
}
Register(brushContainerAsset);
brushContainerAsset.CreateInstances();
}
}
public static ChiselGeneratedObjects Create(GameObject parentGameObject)
{
var parentTransform = parentGameObject.transform;
// Make sure there's not a dangling container out there from a previous version
var existingContainer = parentTransform.FindChildByName(kGeneratedContainerName);
ChiselObjectUtility.SafeDestroy(existingContainer, ignoreHierarchyEvents: true);
var gameObjectState = GameObjectState.Create(parentGameObject);
var container = ChiselObjectUtility.CreateGameObject(kGeneratedContainerName, parentTransform, gameObjectState);
var containerTransform = container.transform;
var colliderContainer = ChiselObjectUtility.CreateGameObject(kGeneratedMeshColliderName, containerTransform, gameObjectState);
Debug.Assert((int)LayerUsageFlags.Renderable == 1);
Debug.Assert((int)LayerUsageFlags.CastShadows == 2);
Debug.Assert((int)LayerUsageFlags.ReceiveShadows == 4);
Debug.Assert((int)LayerUsageFlags.RenderReceiveCastShadows == (1 | 2 | 4));
var renderables = new ChiselRenderObjects[]
{
new ChiselRenderObjects()
{
invalid = true
},
ChiselRenderObjects.Create(kGeneratedMeshRendererNames[1], containerTransform, gameObjectState, LayerUsageFlags.Renderable),
ChiselRenderObjects.Create(kGeneratedMeshRendererNames[2], containerTransform, gameObjectState, LayerUsageFlags.CastShadows),
ChiselRenderObjects.Create(kGeneratedMeshRendererNames[3], containerTransform, gameObjectState, LayerUsageFlags.Renderable | LayerUsageFlags.CastShadows),
new ChiselRenderObjects()
{
invalid = true
},
ChiselRenderObjects.Create(kGeneratedMeshRendererNames[5], containerTransform, gameObjectState, LayerUsageFlags.Renderable | LayerUsageFlags.ReceiveShadows),
new ChiselRenderObjects()
{
invalid = true
},
ChiselRenderObjects.Create(kGeneratedMeshRendererNames[7], containerTransform, gameObjectState, LayerUsageFlags.Renderable | LayerUsageFlags.CastShadows | LayerUsageFlags.ReceiveShadows),
};
var meshRenderers = new MeshRenderer[]
{
renderables[1].meshRenderer,
renderables[2].meshRenderer,
renderables[3].meshRenderer,
renderables[5].meshRenderer,
renderables[7].meshRenderer
};
renderables[1].invalid = false;
renderables[2].invalid = false;
renderables[3].invalid = false;
renderables[5].invalid = false;
renderables[7].invalid = false;
var debugHelpers = new ChiselRenderObjects[kDebugHelperCount];
var debugMeshRenderers = new MeshRenderer[kDebugHelperCount];
for (int i = 0; i < kDebugHelperCount; i++)
{
debugHelpers[i] = ChiselRenderObjects.Create(kGeneratedDebugRendererNames[i], containerTransform, gameObjectState, AssignMeshesJob.kGeneratedDebugRendererFlags[i].Item1, debugHelperRenderer: true);
debugMeshRenderers[i] = debugHelpers[0].meshRenderer;
debugHelpers[i].invalid = false;
}
var result = new ChiselGeneratedObjects
{
generatedDataContainer = container,
colliderContainer = colliderContainer,
colliders = new ChiselColliderObjects[0],
renderables = renderables,
meshRenderers = meshRenderers,
debugHelpers = debugHelpers,
debugMeshRenderers = debugMeshRenderers
};
Debug.Assert(IsValid(result));
return(result);
}
static readonly ModelState __modelState = new ModelState(); // static to avoid allocations
public void Rebuild(ChiselModel model)
{
if (model.generatedMeshes == null ||
model.generatedMeshes.Length == 0)
{
// Destroy leftover components in model lookups
DestroyAllRegisteredGeneratedComponentsInModel(model);
RemoveContainerGameObject(model);
}
else
{
if (!model.IsInitialized)
{
model.OnInitialize();
}
if (!model.GeneratedDataTransform)
{
DestroyAllRegisteredGeneratedComponentsInModel(model);
CreateContainerGameObject(model);
}
var modelGameObject = model.gameObject;
#if UNITY_EDITOR
__modelState.staticFlags = UnityEditor.GameObjectUtility.GetStaticEditorFlags(modelGameObject);
#endif
__modelState.modelGameObject = modelGameObject;
__modelState.modelTransform = model.hierarchyItem.Transform;
__modelState.layer = modelGameObject.layer;
__modelState.containerGameObject = model.GeneratedDataContainer;
__modelState.containerTransform = model.GeneratedDataTransform;
__modelState.existingRenderComponents = model.generatedRenderComponents;
__modelState.existingMeshColliders = model.generatedMeshColliders;
UpdateModelFlags(model);
UpdateContainerFlags(model, __modelState);
// Build components for generatedMesh, re-use existing components if they're available (& remove from lookups)
updateMeshRenderers.Clear();
updateMeshColliders.Clear();
for (int i = 0; i < model.generatedMeshes.Length; i++)
{
var generatedMesh = model.generatedMeshes[i];
BuildComponents(model, __modelState, generatedMesh);
}
UpdateComponents(model, updateMeshRenderers, updateMeshColliders);
updateMeshRenderers.Clear();
updateMeshColliders.Clear();
// Destroy leftover components in model lookups
DestroyAllRegisteredGeneratedComponentsInModel(model);
// Rebuild component lookup tables used by generatedMeshes
BuildGeneratedComponentLookupTables(model);
var containerTransform = __modelState.containerTransform;
for (int c = containerTransform.childCount - 1; c >= 0; c--)
{
var child = containerTransform.GetChild(c);
if (!model.generatedComponents.Contains(child))
{
ChiselObjectUtility.SafeDestroy(child.gameObject);
}
}
}
// to avoid dangling memory
__modelState.modelGameObject = null;
__modelState.modelTransform = null;
__modelState.containerGameObject = null;
__modelState.containerTransform = null;
}