public static Material LoadSubstanceMaterialWithIndex(string materialPath, int substanceMaterialIndex)
{
Material material = LoadUnityMaterial(materialPath);
#if UNITY_2017_4_OR_NEWER || UNITY_2018_1_OR_NEWER
Debug.LogErrorFormat("Houdini Engine for Unity does not support the new Substance plugin as of yet!");
#elif UNITY_EDITOR
if (material != null)
{
string assetPath = HEU_AssetDatabase.GetAssetPath(material);
SubstanceImporter substanceImporter = AssetImporter.GetAtPath(assetPath) as SubstanceImporter;
if(substanceMaterialIndex >= 0 && substanceMaterialIndex < substanceImporter.GetMaterialCount())
{
material = substanceImporter.GetMaterials()[substanceMaterialIndex];
}
}
#endif
if (material != null)
{
Debug.LogFormat("Loaded Substance material with index {0} from path {1}.", substanceMaterialIndex, materialPath);
}
else
{
Debug.LogWarningFormat("Failed to load Substance material with index {0} from path {1}.", substanceMaterialIndex, materialPath);
}
return material;
}
void Start()
{
Assert.IsNotNull(m_TargetGameObject);
m_Renderer = m_TargetGameObject.GetComponent <Renderer>();
Assert.IsNotNull(m_Renderer);
Object[] obj_array = Resources.LoadAll("SubstanceArch", typeof(UnityEditor.SubstanceArchive));
foreach (Object obj in obj_array)
{
SubstanceArchive sbs = obj as SubstanceArchive;
// https://forum.unity.com/threads/substance-proceduralmaterial-to-material-possible.200767/
string fromPath = AssetDatabase.GetAssetPath(sbs.GetInstanceID());
SubstanceImporter fromImporter = AssetImporter.GetAtPath(fromPath) as SubstanceImporter;
int fromMaterialCount = fromImporter.GetMaterialCount();
ProceduralMaterial[] fromMaterials = fromImporter.GetMaterials();
foreach (ProceduralMaterial proc in fromMaterials)
{
m_ProcMaterialList.Add(proc);
}
}
Debug.Log("m_ProcMaterialArray.Length = " + m_ProcMaterialList.Count);
/*
* m_ProcMaterialArray =
* Resources.FindObjectsOfTypeAll( typeof( ProceduralMaterial ) ) as ProceduralMaterial[];
* Debug.Log( "m_ProcMaterialArray.Length = " + m_ProcMaterialArray.Length );
* foreach ( ProceduralMaterial proc_mat in m_ProcMaterialArray )
* {
* Debug.Log( "proc_mat.name = " + proc_mat.name );
* }
*/
/*
* m_Texture =
* Resources.Load("ground_rock_face/resources/ground_rock_face_basecolor") as Texture2D;
* Debug.Log( "m_Texture.name = " + m_Texture.name );
*/
StartCoroutine("ChangeProcMaterial");
}
void OnGUI()
{
if (size == 0)
{
size = 1;
}
size = EditorGUILayout.IntField("Substances", size);
if (substances == null)
{
substances = new SubstanceArchive[size];
}
if (substances.Length != size)
{
SubstanceArchive[] cache = substances;
substances = new SubstanceArchive[size];
for (int i = 0; i < (cache.Length > size ? size : cache.Length); i++)
{
substances[i] = cache[i];
}
}
for (int i = 0; i < size; i++)
{
substances[i] = EditorGUILayout.ObjectField("Substance " + (i + 1), substances[i], typeof(SubstanceArchive), false) as SubstanceArchive;
}
if (GUILayout.Button("Extract"))
{
for (int subs = 0; subs < size; subs++)
{
SubstanceArchive substance = substances[subs];
if (substance == null)
{
continue;
}
string substancePath = AssetDatabase.GetAssetPath(substance.GetInstanceID());
SubstanceImporter substanceImporter = AssetImporter.GetAtPath(substancePath) as SubstanceImporter;
int substanceMaterialCount = substanceImporter.GetMaterialCount();
ProceduralMaterial[] substanceMaterials = substanceImporter.GetMaterials();
if (substanceMaterialCount <= 0)
{
continue;
}
string basePath = substancePath.Replace("/" + substance.name + ".sbsar", "");
if (!Directory.Exists(basePath + "/" + substance.name))
{
AssetDatabase.CreateFolder(basePath, substance.name);
AssetDatabase.ImportAsset(basePath + "/" + substance.name);
}
if (!Directory.Exists("EXPORT_HERE"))
{
Directory.CreateDirectory("EXPORT_HERE");
}
System.Type substanceImporterType = typeof(SubstanceImporter);
MethodInfo exportBitmaps = substanceImporterType.GetMethod("ExportBitmaps", BindingFlags.Instance | BindingFlags.Public);
if (null == exportBitmaps)
{
return;
}
foreach (ProceduralMaterial substanceMaterial in substanceMaterials)
{
substanceMaterial.isReadable = true;//@zpj
bool generateAllOutputs = substanceImporter.GetGenerateAllOutputs(substanceMaterial);
if (!Directory.Exists(basePath + "/" + substance.name + "/" + substanceMaterial.name))
{
AssetDatabase.CreateFolder(basePath + "/" + substance.name, substanceMaterial.name);
AssetDatabase.ImportAsset(basePath + "/" + substance.name + "/" + substanceMaterial.name);
}
string materialPath = basePath + "/" + substance.name + "/" + substanceMaterial.name + "/";
Material newMaterial = new Material(substanceMaterial.shader);
newMaterial.CopyPropertiesFromMaterial(substanceMaterial);
AssetDatabase.CreateAsset(newMaterial, materialPath + substanceMaterial.name + ".mat");
AssetDatabase.ImportAsset(materialPath + substanceMaterial.name + ".mat");
substanceImporter.SetGenerateAllOutputs(substanceMaterial, true);
exportBitmaps.Invoke(substanceImporter, new object[] { substanceMaterial, @"EXPORT_HERE", false });
if (!generateAllOutputs)
{
substanceImporter.SetGenerateAllOutputs(substanceMaterial, false);
}
string[] exportedTextures = Directory.GetFiles("EXPORT_HERE");
if (exportedTextures.Length > 0)
{
string TmpfilePath = string.Empty;
foreach (string exportedTexture in exportedTextures)
{
TmpfilePath = materialPath + exportedTexture.Replace("EXPORT_HERE", "");
if (File.Exists(TmpfilePath))
{
File.Delete(TmpfilePath);
//Debug.Log(TmpfilePath);
}
File.Move(exportedTexture, TmpfilePath);
}
}
AssetDatabase.Refresh();
int propertyCount = ShaderUtil.GetPropertyCount(newMaterial.shader);
Texture[] materialTextures = substanceMaterial.GetGeneratedTextures();
if ((materialTextures.Length <= 0) || (propertyCount <= 0))
{
continue;
}
Texture newTmpTexture = new Texture();
foreach (ProceduralTexture materialTexture in materialTextures)
{
string newTexturePath = materialPath + materialTexture.name + ".tga";// (Clone)
string astmpe = Application.dataPath + newTexturePath.Substring(6);
if (!File.Exists(astmpe))
{
newTexturePath = materialPath + materialTexture.name + " (Clone).tga";
astmpe = Application.dataPath + newTexturePath.Substring(6);
if (!File.Exists(astmpe))
{
Debug.LogError(newTexturePath + "not exist");
}
}
Texture newTextureAsset = (Texture)AssetDatabase.LoadAssetAtPath(newTexturePath, typeof(Texture));
if (null != newTextureAsset)
{
try
{
for (int i = 0; i < propertyCount; i++)
{
if (ShaderUtil.GetPropertyType(newMaterial.shader, i) == ShaderUtil.ShaderPropertyType.TexEnv)
{
string propertyName = ShaderUtil.GetPropertyName(newMaterial.shader, i);
newTmpTexture = newMaterial.GetTexture(propertyName);
//Debug.Log(newTmpTexture.name + " and " + propertyName + " new assset " + newTextureAsset.name);
if (null != newTmpTexture && (newTmpTexture.name == newTextureAsset.name || newTmpTexture.name + " (Clone)" == newTextureAsset.name))
{
newMaterial.SetTexture(propertyName, newTextureAsset);
}
}
}
}
catch (System.Exception ex)
{
Debug.Log(ex.Message);
}
}
ProceduralOutputType outType = materialTexture.GetProceduralOutputType();
if (materialTexture.GetProceduralOutputType() == ProceduralOutputType.Normal)
{
TextureImporter textureImporter = AssetImporter.GetAtPath(newTexturePath) as TextureImporter;
if (null != textureImporter)
{
textureImporter.textureType = TextureImporterType.Bump;
}
AssetDatabase.ImportAsset(newTexturePath);
}
}
}
if (Directory.Exists("EXPORT_HERE"))
{
Directory.Delete("EXPORT_HERE");
}
}
}
}
public static void ExportAllSubstancesInDirectory(string dir)
{
string unity_assets_path = Application.dataPath;
string unity_export_texture_dir = Path.Combine(Path.Combine(unity_assets_path, "Textures"), dir);
string overload_editor_root_dir = OverloadLevelConverter.FindEditorRootFolder();
string overload_texture_export_dir = Path.Combine(overload_editor_root_dir, dir + "Textures");
int export_count = 0;
string[] files = Directory.GetFiles(unity_export_texture_dir, "*.sbsar", SearchOption.AllDirectories);
int total_files = files.Length;
int files_processed = 0;
try {
foreach (string filename in files)
{
// Get a usable path for LoadAsset
string unity_asset_location = Path.Combine("Assets", OverloadLevelEditor.Utility.GetRelativeFilenameFromDirectory(unity_assets_path, filename)).Replace('\\', '/');
// Show progress so far
float prog_perc = (float)files_processed / (float)total_files;
++files_processed;
if (EditorUtility.DisplayCancelableProgressBar("Exporting Substances", unity_asset_location, prog_perc))
{
Debug.LogWarning("User cancelled Substance export");
break;
}
SubstanceImporter sub_imp = (SubstanceImporter)AssetImporter.GetAtPath(unity_asset_location);
int sub_imp_count = sub_imp.GetMaterialCount();
if (sub_imp_count <= 0)
{
continue;
}
// In order to call GetPixels32 the material must be set to Raw format and only Raw
// Fixup those that need to be fixed, and then restore them back.
var materials_to_restore_settings = new Dictionary <string, SubstanceTextureSettings>();
ProceduralMaterial[] proc_mats = sub_imp.GetMaterials();
foreach (ProceduralMaterial proc_mat in proc_mats)
{
int maxTextureWidth;
int maxTextureHeight;
int textureFormat;
int loadBehavior;
bool res = sub_imp.GetPlatformTextureSettings(proc_mat.name, string.Empty, out maxTextureWidth, out maxTextureHeight, out textureFormat, out loadBehavior);
if (!res)
{
Debug.LogError(string.Format("Failed to read platform settings for '{0}'", proc_mat.name));
continue;
}
if (textureFormat == (int)SubstanceTextureFormat.Raw)
{
continue;
}
// Convert to Raw format
materials_to_restore_settings.Add(proc_mat.name, new SubstanceTextureSettings()
{
mat = proc_mat, maxTextureWidth = maxTextureWidth, maxTextureHeight = maxTextureHeight, textureFormat = textureFormat, loadBehavior = loadBehavior
});
sub_imp.SetPlatformTextureSettings(proc_mat, string.Empty, maxTextureWidth, maxTextureHeight, (int)SubstanceTextureFormat.Raw, loadBehavior);
}
if (materials_to_restore_settings.Count != 0)
{
AssetDatabase.ImportAsset(unity_asset_location);
sub_imp = (SubstanceImporter)AssetImporter.GetAtPath(unity_asset_location);
proc_mats = sub_imp.GetMaterials();
}
try {
foreach (ProceduralMaterial proc_mat in proc_mats)
{
proc_mat.isReadable = true;
proc_mat.RebuildTexturesImmediately();
if (proc_mat.isProcessing)
{
Debug.LogError(string.Format("{0} is still processing", proc_mat.name));
continue;
}
Texture[] mat_texs = proc_mat.GetGeneratedTextures();
if (mat_texs.Length <= 0)
{
continue;
}
string material_name = proc_mat.name;
// Only look for the Diffuse texture
foreach (ProceduralTexture mat_tex in mat_texs.Where(m => m.name.EndsWith("_Diffuse", System.StringComparison.InvariantCultureIgnoreCase)))
{
// Copy the texture into a Texture2D, then write that out
Texture2D new_tex = new Texture2D(mat_tex.width, mat_tex.height);
new_tex.anisoLevel = mat_tex.anisoLevel;
new_tex.filterMode = mat_tex.filterMode;
new_tex.mipMapBias = mat_tex.mipMapBias;
new_tex.wrapMode = mat_tex.wrapMode;
Color32[] pixels = mat_tex.GetPixels32(0, 0, mat_tex.width, mat_tex.height);
for (int i = 0; i < pixels.Length; i++)
{
pixels[i].a = 255;
}
new_tex.SetPixels32(pixels);
new_tex.Apply();
// Scale down to 512x512 before final export
TextureScale.Bilinear(new_tex, 512, 512);
string new_tex_name = Path.Combine(overload_texture_export_dir, material_name + ".png");
File.WriteAllBytes(new_tex_name, new_tex.EncodeToPNG());
export_count += 1;
}
}
}
finally {
if (materials_to_restore_settings.Count != 0)
{
// Restore settings
foreach (var kvp in materials_to_restore_settings)
{
//var name = kvp.Key;
var settings = kvp.Value;
sub_imp.SetPlatformTextureSettings(settings.mat, string.Empty, settings.maxTextureWidth, settings.maxTextureHeight, settings.textureFormat, settings.loadBehavior);
}
AssetDatabase.ImportAsset(unity_asset_location);
}
}
}
}
finally {
EditorUtility.ClearProgressBar();
Debug.Log("Finished exporting " + export_count.ToString() + " diffuse textures to " + overload_texture_export_dir);
}
}