/// <summary>
/// Ensures that <see cref="ProceduralMesh"/> component is presents and returns it.
/// </summary>
/// <returns>
/// The <see cref="ProceduralMesh"/> component.
/// </returns>
internal ProceduralMesh PrepareProceduralMesh()
{
if (this.ProceduralMesh == null)
{
var t = this.transform;
this.proceduralMesh = t.GetComponentInChildren <ProceduralMesh>();
if (this.proceduralMesh == null)
{
// Entire procedural mesh component is missing, restore it!
var proceduralGO = new GameObject("_procedural");
var proceduralTransform = proceduralGO.transform;
proceduralTransform.SetParent(t, false);
proceduralTransform.localPosition = new Vector3(
this.firstColumn * this.tileSystem.CellSize.x,
this.firstRow * -this.tileSystem.CellSize.y,
0f
);
this.proceduralMesh = proceduralGO.AddComponent <ProceduralMesh>();
this.proceduralMesh.InitialUpdateMesh();
InternalUtility.HideEditorWireframe(proceduralGO);
}
else if (this.proceduralMesh.mesh == null)
{
// Procedural mesh component is available, but mesh is missing.
this.proceduralMesh.InitialUpdateMesh();
InternalUtility.HideEditorWireframe(this.proceduralMesh.gameObject);
}
}
return(this.proceduralMesh);
}
/// <summary>
/// Apply runtime stripping options to a tile system.
/// </summary>
/// <remarks>
/// <para>At runtime only a basic level of stripping will be automatically applied
/// to tile system upon <c>Awake</c> when runtime stripping is enabled. Tile systems
/// should be optimised to take full advantage of the provided stripping capabilities.</para>
/// </remarks>
/// <param name="tileSystem">Tile system.</param>
public static void ApplyRuntimeStripping(TileSystem tileSystem)
{
if (tileSystem.chunks != null)
{
// Does tile data need to be stripped?
if (tileSystem.StripSystemComponent || tileSystem.StripChunkMap || tileSystem.StripTileData)
{
foreach (var chunk in tileSystem.chunks)
{
if (chunk == null)
{
continue;
}
chunk.tiles = null;
InternalUtility.Destroy(chunk);
}
// Tile system is no longer editable.
tileSystem.isEditable = false;
}
// If not, should brush references be stripped from tile data?
else if (tileSystem.StripBrushReferences)
{
foreach (var chunk in tileSystem.chunks)
{
if (chunk == null || chunk.tiles == null)
{
continue;
}
foreach (var tile in chunk.tiles)
{
if (tile != null)
{
tile.brush = null;
}
}
}
}
// Is chunk map to be stripped?
if (tileSystem.StripChunkMap)
{
tileSystem.chunks = null;
// Tile system is no longer editable.
tileSystem.isEditable = false;
}
}
// Should this tile system component be stripped?
if (tileSystem.StripSystemComponent)
{
InternalUtility.Destroy(tileSystem);
}
// Runtime stripping has already been applied!
tileSystem.applyRuntimeStripping = false;
}
/// <summary>
/// Strip chunk game objects from tile system and reparent tile objects into game
/// object of tile system.
/// </summary>
/// <param name="tileSystem">Tile system.</param>
private static void StripChunks(TileSystem tileSystem)
{
if (tileSystem.chunks != null)
{
foreach (var chunk in tileSystem.chunks)
{
if (chunk == null)
{
continue;
}
ReparentChildren(chunk.transform, tileSystem.transform);
// Dereference tile data and destroy associated game object.
chunk.tiles = null;
InternalUtility.Destroy(chunk.gameObject);
}
// Clear chunk map.
tileSystem.chunks = null;
}
// Tile system is no longer editable.
tileSystem.isEditable = false;
}
/// <summary>
/// Strip game object when it contains no components and has no children.
/// </summary>
/// <param name="obj">Transform of game object to consider stripping.</param>
/// <returns>
/// A value of <c>true</c> if game object was stripped; otherwise <c>false</c>.
/// </returns>
public static bool StripEmptyGameObject(Transform obj)
{
if (obj.childCount == 0)
{
var components = obj.GetComponents <Component>();
if (components.Length == 1 && components[0] is Transform)
{
InternalUtility.Destroy(obj.gameObject);
return(true);
}
}
return(false);
}
/// <summary>
/// Strip plop instance and group components for tile system.
/// </summary>
/// <param name="system">Tile system.</param>
private static void StripPlopComponents(TileSystem system)
{
// Strip `PlopGroup` components from tile system.
foreach (var plopGroup in system.GetComponentsInChildren <PlopGroup>())
{
InternalUtility.Destroy(plopGroup);
}
// Strip `PlopInstance` components which are associated from tile system.
foreach (var plopInstance in Resources.FindObjectsOfTypeAll <PlopInstance>())
{
if (plopInstance.Owner == system)
{
InternalUtility.Destroy(plopInstance);
}
}
}
/// <summary>
/// Remove empty chunk game objects.
/// </summary>
/// <param name="tileSystem">Tile system.</param>
private static void StripEmptyChunks(TileSystem tileSystem)
{
if (tileSystem.chunks == null)
{
return;
}
Transform chunkTransform;
Component[] components;
int extraCount;
for (int i = 0; i < tileSystem.chunks.Length; ++i)
{
if (tileSystem.chunks[i] == null)
{
continue;
}
chunkTransform = tileSystem.chunks[i].transform;
// Strip chunk if it doesn't contain any child game objects and if it
// doesn't contain extra components.
if (chunkTransform.childCount == 0)
{
components = chunkTransform.GetComponents <Component>();
// Count extra components (other than Transform and Chunk).
extraCount = components.Length;
for (int j = 0; j < components.Length; ++j)
{
if (components[j] is Transform || components[j] is Chunk)
{
--extraCount;
}
}
// Chunk can be stripped if there are no extra components.
if (extraCount == 0)
{
InternalUtility.Destroy(chunkTransform.gameObject);
}
}
}
}
/// <inheritdoc/>
protected internal override void PostProcessTile(IBrushContext context, TileData tile)
{
if (tile == null)
{
return;
}
var go = tile.gameObject;
if (go != null)
{
// Assign tag and layer to tile.
go.tag = this.tag;
go.layer = this.layer;
InternalUtility.HideEditorWireframe(go);
}
}
private void OnDestroy()
{
//!HACK: Workaround bug in Unity where delayed action of Object.Destroy
// is not respected when stopping play mode in-editor.
InternalUtility.DestroyImmediate(this.mesh);
}