Misaki/com.misaki.art-tools
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added GenerateMask to AssetsHelpers;

Browse Source
This commit is contained in:
Misaki
2024-12-26 00:44:11 +09:00
parent 509357011c
commit 2a455513bc
47 changed files with 974 additions and 297 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
Editor/AssetsHelpers/Implementation/Meshes/ExtractMaterials.meta Normal file
View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: c61caf20baa490d44a8d447822f5225d
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

37
Editor/AssetsHelpers/Implementation/Meshes/ExtractMaterials/ExtractMaterialsMenu.cs Normal file
View File

@@ -0,0 +1,37 @@
using UnityEditor;
namespace Misaki.ArtToolEditor
{
public class ExtractMaterialsMenu
{
private const string Material_Extension = ".mat";
[MenuItem("Assets/Art Tools/Mesh Helpers/Extract Materials", true)]
public static bool ExtractMaterialsValidator()
{
foreach (var selectedObject in Selection.objects)
{
var assetImporter = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(selectedObject));
if (assetImporter is not ModelImporter)
{
return false;
}
}
return true;
}
[MenuItem("Assets/Art Tools/Mesh Helpers/Extract Materials")]
public static void ExtractMaterials()
{
var window = EditorWindow.GetWindow<OutputOptionsWindow>(true, "Extract Materials Output Options");
window.WithItemSource(Selection.objects);
window.RegisterVisualProvider<ExtractMaterialsVisualProvider>();
window.RegisterProcessor<ExtractMaterialsProcessor>();
window.InitializeAndShow();
}
}
}

2
Editor/AssetsHelpers/Implementation/Meshes/ExtractMaterials/ExtractMaterialsMenu.cs.meta Normal file
View File

@@ -0,0 +1,2 @@
fileFormatVersion: 2
guid: c21cf688d17737c4d91cec961bfce976

75
Editor/AssetsHelpers/Implementation/Meshes/ExtractMaterials/ExtractMaterialsProcessor.cs Normal file
View File

@@ -0,0 +1,75 @@
using System.Collections.Generic;
using System.IO;
using System.Linq;
using UnityEditor;
using UnityEngine;
namespace Misaki.ArtToolEditor
{
internal class ExtractMaterialsProcessor : IAssetsProcessor
{
private const string Material_Extension = ".mat";
public bool useMaterialRemap = false;
public ModelImporterMaterialLocation materialLocation = ModelImporterMaterialLocation.InPrefab;
public ModelImporterMaterialName materialRemapNamingOption = ModelImporterMaterialName.BasedOnMaterialName;
public ModelImporterMaterialSearch materialRemapSearchOption = ModelImporterMaterialSearch.RecursiveUp;
public void OnPreProcess(AssetsProcessContext context)
{
context.userData = new HashSet<string>();
}
public void OnProcess(Object source, string outputDirectory, AssetsProcessContext context)
{
var assetsToReload = (HashSet<string>)context.userData;
var assetImporter = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(source));
if (assetImporter is not ModelImporter modelImporter)
{
return;
}
if (useMaterialRemap)
{
modelImporter.materialLocation = materialLocation;
modelImporter.SearchAndRemapMaterials(materialRemapNamingOption, materialRemapSearchOption);
modelImporter.SaveAndReimport();
return;
}
else
{
var materials = AssetDatabase.LoadAllAssetsAtPath(modelImporter.assetPath).Where(x => x.GetType() == typeof(Material));
foreach (var material in materials)
{
var newAssetPath = Path.Combine(outputDirectory, material.name) + Material_Extension;
newAssetPath = AssetDatabase.GenerateUniqueAssetPath(newAssetPath);
var error = AssetDatabase.ExtractAsset(material, newAssetPath);
if (string.IsNullOrEmpty(error))
{
assetsToReload.Add(modelImporter.assetPath);
}
}
}
}
public void OnPostProcess(AssetsProcessContext context)
{
var assetsToReload = (HashSet<string>)context.userData;
foreach (var assetPath in assetsToReload)
{
if (string.IsNullOrEmpty(assetPath))
{
return;
}
AssetDatabase.WriteImportSettingsIfDirty(assetPath);
AssetDatabase.ImportAsset(assetPath, ImportAssetOptions.ForceUpdate);
}
}
}
}

2
Editor/AssetsHelpers/Implementation/Meshes/ExtractMaterials/ExtractMaterialsProcessor.cs.meta Normal file
View File

@@ -0,0 +1,2 @@
fileFormatVersion: 2
guid: ae6fdf97993458e47add233725aecaa4

66
Editor/AssetsHelpers/Implementation/Meshes/ExtractMaterials/ExtractMaterialsVisualProvider.cs Normal file
View File

@@ -0,0 +1,66 @@
using System.Collections.Generic;
using Unity.Properties;
using UnityEditor;
using UnityEngine.UIElements;
namespace Misaki.ArtToolEditor
{
internal class ExtractMaterialsVisualProvider : OptionsVisualProvider
{
internal override VisualElement ContentAfterList()
{
var root = new VisualElement();
var materialRemapOptionContainer = new VisualElement()
{
style =
{
display = DisplayStyle.None,
}
};
var useMaterialRemapField = new DropdownField("Use Material Remap", new List<string> { "False", "True" }, "False");
useMaterialRemapField.SetBinding(
nameof(DropdownField.index),
new DataBinding()
{
dataSourcePath = PropertyPath.FromName(nameof(ExtractMaterialsProcessor.useMaterialRemap))
});
useMaterialRemapField.RegisterValueChangedCallback(evt =>
{
materialRemapOptionContainer.style.display = evt.newValue == "True" ? DisplayStyle.Flex : DisplayStyle.None;
});
var materialLocationField = new EnumField("Location", ModelImporterMaterialLocation.External);
materialLocationField.SetBinding(
nameof(EnumField.value),
new DataBinding()
{
dataSourcePath = PropertyPath.FromName(nameof(ExtractMaterialsProcessor.materialLocation))
});
var materialRemapNamingOptionField = new EnumField("Naming Option", ModelImporterMaterialName.BasedOnTextureName);
materialRemapNamingOptionField.SetBinding(
nameof(EnumField.value),
new DataBinding()
{
dataSourcePath = PropertyPath.FromName(nameof(ExtractMaterialsProcessor.materialRemapNamingOption))
});
var materialRemapSearchOptionField = new EnumField("Search Option", ModelImporterMaterialSearch.Local);
materialRemapSearchOptionField.SetBinding(
nameof(EnumField.value),
new DataBinding()
{
dataSourcePath = PropertyPath.FromName(nameof(ExtractMaterialsProcessor.materialRemapSearchOption))
});
materialRemapOptionContainer.Add(materialLocationField);
materialRemapOptionContainer.Add(materialRemapNamingOptionField);
materialRemapOptionContainer.Add(materialRemapSearchOptionField);
root.Add(useMaterialRemapField);
root.Add(materialRemapOptionContainer);
return root;
}
}
}

2
Editor/AssetsHelpers/Implementation/Meshes/ExtractMaterials/ExtractMaterialsVisualProvider.cs.meta Normal file
View File

@@ -0,0 +1,2 @@
fileFormatVersion: 2
guid: 74347edff42a5cd47a6a5d4989210334

123
Editor/AssetsHelpers/Implementation/Meshes/RemapMaterials.cs
View File

@@ -1,123 +0,0 @@
using System.Collections.Generic;
using System.IO;
using System.Linq;
using UnityEditor;
using UnityEngine;
using UnityEngine.UIElements;
namespace Misaki.ArtToolEditor
{
public class RemapMaterials
{
private const string Material_Extension = ".mat";
private static bool _useMaterialRemap = false;
private static ModelImporterMaterialLocation _materialLocation = ModelImporterMaterialLocation.InPrefab;
private static ModelImporterMaterialName _materialRemapNamingOption = ModelImporterMaterialName.BasedOnMaterialName;
private static ModelImporterMaterialSearch _materialRemapSearchOption = ModelImporterMaterialSearch.RecursiveUp;
[MenuItem("Assets/Art Tools/Mesh Helpers/Extract Materials", true)]
public static bool CreateDecalMenuValidator()
{
foreach (var selectedObject in Selection.objects)
{
var assetImporter = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(selectedObject));
if (assetImporter is not ModelImporter)
{
return false;
}
}
return true;
}
[MenuItem("Assets/Art Tools/Mesh Helpers/Extract Materials")]
public static void CreateDecalMenu()
{
var window = EditorWindow.GetWindow<OutputOptionsWindow>(true, "Extract Materials Output Options");
window.WithSource(Selection.objects);
window.WithContentBeforeButton(() =>
{
var root = new VisualElement();
var materialRemapOptionContainer = new VisualElement()
{
style =
{
display = DisplayStyle.None,
}
};
var useMaterialRemap = new DropdownField("Use Material Remap", new List<string> { "False", "True" }, "False");
useMaterialRemap.RegisterValueChangedCallback(evt =>
{
_useMaterialRemap = evt.newValue == "True";
materialRemapOptionContainer.style.display = _useMaterialRemap ? DisplayStyle.Flex : DisplayStyle.None;
});
var materialLocation = new EnumField("Material Location", _materialLocation);
materialLocation.RegisterValueChangedCallback(evt => _materialLocation = (ModelImporterMaterialLocation)evt.newValue);
var materialRemapNamingOption = new EnumField("Material Naming Option", _materialRemapNamingOption);
materialRemapNamingOption.RegisterValueChangedCallback(evt => _materialRemapNamingOption = (ModelImporterMaterialName)evt.newValue);
var materialRemapSearchOption = new EnumField("Material Search Option", _materialRemapSearchOption);
materialRemapSearchOption.RegisterValueChangedCallback(evt => _materialRemapSearchOption = (ModelImporterMaterialSearch)evt.newValue);
materialRemapOptionContainer.Add(materialLocation);
materialRemapOptionContainer.Add(materialRemapNamingOption);
materialRemapOptionContainer.Add(materialRemapSearchOption);
root.Add(useMaterialRemap);
root.Add(materialRemapOptionContainer);
return root;
});
window.WithOutput(ExtractMaterialsInternal);
window.WithPostOutput(ExtractMaterialsPostInternal);
window.ShowUtility();
}
private static string ExtractMaterialsInternal(Object inputObject, string outputDirectory)
{
var assetImporter = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(inputObject));
if (assetImporter is not ModelImporter modelImporter)
{
return null;
}
if (_useMaterialRemap)
{
modelImporter.materialLocation = _materialLocation;
modelImporter.SearchAndRemapMaterials(_materialRemapNamingOption, _materialRemapSearchOption);
modelImporter.SaveAndReimport();
return null;
}
else
{
var materials = AssetDatabase.LoadAllAssetsAtPath(modelImporter.assetPath).Where(x => x.GetType() == typeof(Material));
foreach (var material in materials)
{
var newAssetPath = Path.Combine(outputDirectory, material.name) + Material_Extension;
newAssetPath = AssetDatabase.GenerateUniqueAssetPath(newAssetPath);
AssetDatabase.ExtractAsset(material, newAssetPath);
}
return modelImporter.assetPath;
}
}
private static void ExtractMaterialsPostInternal(string assetPath)
{
if (string.IsNullOrEmpty(assetPath))
{
return;
}
AssetDatabase.WriteImportSettingsIfDirty(assetPath);
AssetDatabase.ImportAsset(assetPath, ImportAssetOptions.ForceUpdate);
}
}
}

2
Editor/AssetsHelpers/Implementation/Meshes/RemapMaterials.cs.meta
View File

@@ -1,2 +0,0 @@
fileFormatVersion: 2
guid: 9cc9f1a0be83aa444884c32f825c5303