protected override void OnApplyChanges()
{
// Do not proceed if no atlas texture was selected.
if (this.inputNewAutotileArtwork == null)
{
EditorUtility.DisplayDialog(
TileLang.ParticularText("Error", "Autotile artwork was not specified"),
TileLang.Text("Please select artwork for autotile before proceeding."),
TileLang.ParticularText("Action", "Close")
);
return;
}
// Warn user if modified atlas will contain impossible brushes.
if (BrushUtility.WouldHaveImpossibleTilesetBrushes(this.tileset, this.inputTileWidth, this.inputTileHeight, this.inputBorderSize))
{
if (!EditorUtility.DisplayDialog(
TileLang.Text("Warning, brushes will be deleted"),
TileLang.Text("Modified atlas contains fewer tiles than previously. Previously created brushes that are out of range will be deleted.\n\nWould you like to proceed?"),
TileLang.ParticularText("Action", "Yes"),
TileLang.ParticularText("Action", "No")
))
{
return;
}
}
bool refreshProceduralMeshes = !this.inputProcedural && this.autotileTileset.procedural;
// If raw uncompressed variation of autotile is not defined generate from
// current selection.
if (this.inputNewAutotileArtworkUncompressed == null)
{
if (this.inputNewAutotileArtwork == null)
{
Debug.LogError(TileLang.ParticularText("Error", "Invalid autotile artwork was specified."));
return;
}
this.inputNewAutotileArtworkUncompressed = EditorInternalUtility.LoadTextureUncompressed(this.inputNewAutotileArtwork);
}
this.ExpandAutotileArtwork(this.inputBorderSize);
string tilesetBasePath = this.tilesetRecord.AssetPath.Substring(0, this.tilesetRecord.AssetPath.LastIndexOf('/') + 1);
// Save texture asset.
string assetPath = AssetDatabase.GetAssetPath(this.autotileTileset.AtlasTexture);
if (string.IsNullOrEmpty(assetPath) || !assetPath.StartsWith(tilesetBasePath))
{
assetPath = AssetDatabase.GenerateUniqueAssetPath(tilesetBasePath + "atlas.png");
}
this.autotileTileset.AtlasTexture = EditorInternalUtility.SavePngAsset(assetPath, this.expandedAutotileAtlas);
// Update and save material asset.
if (this.autotileTileset.AtlasMaterial == null)
{
this.autotileTileset.AtlasMaterial = new Material(Shader.Find("Rotorz/Tileset/Opaque Unlit"));
this.autotileTileset.AtlasMaterial.mainTexture = this.autotileTileset.AtlasTexture;
assetPath = AssetDatabase.GenerateUniqueAssetPath(tilesetBasePath + "atlas.mat");
AssetDatabase.CreateAsset(this.autotileTileset.AtlasMaterial, assetPath);
AssetDatabase.ImportAsset(assetPath);
}
else
{
this.autotileTileset.AtlasMaterial.mainTexture = this.autotileTileset.AtlasTexture;
EditorUtility.SetDirty(this.autotileTileset.AtlasMaterial);
}
// Calculate metrics for tileset.
var metrics = new TilesetMetrics(this.autotileTileset.AtlasTexture, this.inputTileWidth, this.inputTileHeight, this.inputBorderSize, this.inputDelta);
// Update properties of tileset.
this.autotileTileset.procedural = this.inputProcedural;
this.autotileTileset.ForceClampEdges = this.inputClampEdges;
this.autotileTileset.rawTexture = this.inputNewAutotileArtwork;
this.autotileTileset.SetMetricsFrom(metrics);
this.ClearExpandedAutotileAtlas();
EditorUtility.SetDirty(this.autotileTileset);
// Delete "impossible" tile brushes in tileset.
// For example, an extra brush for a tile that no longer exists.
BrushUtility.DeleteImpossibleTilesetBrushes(this.tileset);
// Ensure that non-procedural meshes are pre-generated if missing.
if (refreshProceduralMeshes)
{
BrushUtility.RefreshNonProceduralMeshes(this.tileset);
}
ToolUtility.RepaintBrushPalette();
// Update procedural meshes for tile systems in scene if necessary.
// Note: Only update if procedural mode of tileset was not modified.
if (this.inputProcedural && this.tileset.procedural)
{
foreach (TileSystem tileSystem in Object.FindObjectsOfType(typeof(TileSystem)))
{
tileSystem.UpdateProceduralTiles(true);
}
}
}
/// <summary>
/// Generate tileset using an atlas brush.
/// </summary>
/// <remarks>
/// <para>One tileset asset is generated for each unique atlas material that
/// exists amongst all defined atlas brushes.</para>
/// </remarks>
/// <param name="brush">Existing atlas brush.</param>
/// <returns>
/// The tileset.
/// </returns>
private Tileset GenerateTilesetFromAtlasBrush(MonoBehaviour brush)
{
MeshRenderer renderer = brush.GetComponent <MeshRenderer>();
if (renderer == null)
{
return(null);
}
Material mat = renderer.sharedMaterial;
if (mat == null)
{
return(null);
}
Texture2D atlasTexture = _fiAtlasTileBrush_atlasTexture.GetValue(brush) as Texture2D;
if (atlasTexture == null)
{
return(null);
}
RtsUpgradedBrushMap map = RtsUpgradedBrushMap.BrushMappings;
Tileset tileset = map.Lookup(mat);
if (tileset != null)
{
return(tileset);
}
// Create folder for atlas assets
string atlasFolder = AssetDatabase.GenerateUniqueAssetPath(BrushUtility.GetBrushAssetPath() + atlasTexture.name);
Directory.CreateDirectory(Directory.GetCurrentDirectory() + "/" + atlasFolder);
// Create material for tileset
Material material = Object.Instantiate(mat) as Material;
material.mainTexture = atlasTexture;
AssetDatabase.CreateAsset(material, atlasFolder + "/atlas.mat");
AssetDatabase.ImportAsset(atlasFolder + "/atlas.mat");
int atlasTileWidth = (int)_fiAtlasTileBrush_atlasTileWidth.GetValue(brush);
int atlasTileHeight = (int)_fiAtlasTileBrush_atlasTileHeight.GetValue(brush);
// Calculate metrics for tileset
TilesetMetrics metrics = new TilesetMetrics(atlasTexture, atlasTileWidth, atlasTileHeight, 0, 0.5f);
// Create new tileset asset.
tileset = ScriptableObject.CreateInstance <Tileset>();
tileset.Initialize(material, atlasTexture, metrics);
tileset.procedural = useProceduralTilesets;
// Save tileset asset.
string assetPath = atlasFolder + "/" + atlasTexture.name + ".set.asset";
AssetDatabase.CreateAsset(tileset, assetPath);
AssetDatabase.ImportAsset(assetPath);
map.SetMapping(mat, tileset);
return(tileset);
}
