Änderungen an Material-Assets in Unity3d vornehmen

Question

Ich überschreibe einige Material-Assets mithilfe eines Editor-Skripts, und Materialien überschreiben sich gut. Ich kann sehen, dass neue Materialeigenschaften angewendet werden und wenn ich auf einzelne Materialien klicke, kann ich neue Texturen sehen usw. Wenn ich jedoch auf "Play" klicke, werden meine Materialien in den Pre-Edit-Status zurückgesetzt. Gleiches geschieht, wenn ich CTR + S drücke. Meine Materialien wurden alle auf das zurückgesetzt, was sie waren.

Wie kann ich die Änderungen in der Datenbank speichern lassen und beibehalten, wenn ich auf "Play" klicke?

using UnityEngine; 
using UnityEditor; 
using Newtonsoft.Json; 
using Unify.Utilities; 
using System.Collections.Generic; 
using System; 
using System.IO; 

public class ProcessMaterials : MonoBehaviour 
{ 
    [MenuItem("Unify/ProcessMaterials")] 
    static void UnifyProcessMaterials() 
    { 
    ImportTextures(); 
    ApplyMaterials(); 
    } 

private static void ImportTextures() 
{ 
    // check if folder exists and create one if not 
    if (!AssetDatabase.IsValidFolder("Assets/Resources")) 
    { 
     AssetDatabase.CreateFolder("Assets", "Resources"); 
    } 

    // load settings file 
    TextAsset ta = Resources.Load("UnifySettings") as TextAsset; 
    string json = ta.text; 
    List<List<UnifyObject>> unifyObj = JsonConvert.DeserializeObject<List<List<UnifyObject>>>(json); 
    List<UnifyObject> allMats = unifyObj[3]; 

    // copy textures over to unity folders 
    HashSet<string> uniqueTextures = new HashSet<string>(); 
    foreach (UnifyObject obj in allMats) 
    { 
     if (obj.DiffuseTexture != null && uniqueTextures.Add(obj.DiffuseTexture)) 
     { 
      CopyImageAsset(obj.DiffuseTexture); 
     } 
     if (obj.BumpTexture != null && uniqueTextures.Add(obj.BumpTexture)) 
     { 
      CopyImageAsset(obj.BumpTexture); 
     } 
     if (obj.TransparencyTexture != null && uniqueTextures.Add(obj.TransparencyTexture)) 
     { 
      CopyImageAsset(obj.TransparencyTexture); 
     } 
     if (obj.EnvironmentTexture != null && uniqueTextures.Add(obj.EnvironmentTexture)) 
     { 
      CopyImageAsset(obj.EnvironmentTexture); 
     } 
    } 
} 

private static void CopyImageAsset(string sourceFilePath) 
{ 
    string fileName = "Resources\\" + Path.GetFileName(sourceFilePath); 
    string destFile = Path.Combine(Application.dataPath, fileName); 

    try 
    { 
     File.Copy(sourceFilePath, destFile, true); 
    } 
    catch (Exception) { } 
} 

private static void ApplyMaterials() 
{ 
    TextAsset ta = Resources.Load("UnifySettings") as TextAsset; 
    string json = ta.text; 
    List<List<UnifyObject>> unifyObj = JsonConvert.DeserializeObject<List<List<UnifyObject>>>(json); 

    GameObject cube; 
    cube = GameObject.CreatePrimitive(PrimitiveType.Cube); 
    Renderer cubeRenderer = cube.GetComponent<Renderer>(); 

    List<UnifyObject> allMaterials = unifyObj[3]; 
    foreach (UnifyObject obj in allMaterials) 
    { 
     // skip layers with no materials assigned/default 
     if (obj.Guid != Guid.Empty.ToString()) 
     { 
      // obj replaces all dashes in names with underscores hence material assets will have different names than in Rhino 
      // if layers had dashes in their names 
      string objUniqueName = obj.UniqueName.Replace("-", "_"); 
      Material m = (Material)AssetDatabase.LoadAssetAtPath("Assets/Resources/Model/Materials/" + objUniqueName + "Mat.mat", typeof(UnityEngine.Object)); 
      if (m != null) 
      { 
       OverrideMaterial(m, obj, cubeRenderer); 
       AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(m)); 
      } 
     } 
    } 
    DestroyImmediate(cube); 
} 

private static Material OverrideMaterial(Material m, UnifyObject obj, Renderer renderer) 
{ 
    renderer.material = m; 
    // set main color 
    // set transparency 
    if (obj.Transparency != "0") 
    { 
     Color newColor = Utilities.ConvertToUnityColor(obj.Diffuse, obj.Transparency); 
     renderer.sharedMaterial.SetFloat("_Mode", 3); 
     renderer.sharedMaterial.SetColor("_Color", newColor); 
    } 
    else 
    { 
     Color newColor = Utilities.ConvertToUnityColor(obj.Diffuse); 
     renderer.sharedMaterial.SetColor("_Color", newColor); 
    } 

    // set main texture 
    if (obj.DiffuseTexture != null) 
    { 
     renderer.sharedMaterial.mainTexture = Utilities.Texture2dFromPath(obj.DiffuseTexture); 
    } 

    // set bump map 
    if (obj.BumpTexture != null) 
    { 
     Texture2D bumpTexture = Utilities.Texture2dFromPath(obj.BumpTexture); 
     float strength = Convert.ToSingle("1.0"); 
     Texture2D normalBump = Utilities.CreateNormalMap(bumpTexture, strength); 
     renderer.sharedMaterial.SetTexture("_BumpMap", normalBump); 
     // need to get that value from Rhino somehow 
     renderer.sharedMaterial.SetFloat("_BumpScale", 0.3f); 
    } 

    // set metallic 
    renderer.sharedMaterial.SetFloat("_Metallic", Utilities.ConvertRange(0, 255, 0, 1, Convert.ToSingle(obj.Metallic))); 

    // set emission color 
    Color emissionColor = Utilities.ConvertToUnityColor(obj.EmissionColor); 
    renderer.sharedMaterial.SetColor("_EmissionColor", emissionColor); 
    return renderer.sharedMaterial; 
} 
} 

Answer 1

Nachdem Sie die Materialien, rufen Sie folgende Funktionen

UnityEditor.EditorUtility.SetDirty(AssetName); 
UnityEditor.AssetDatabase.SaveAssets(); 
UnityEditor.AssetDatabase.Refresh(); 

Wenn die oben beschriebene Methode überschrieben hat nicht funktioniert, eine andere Methode, die wird funktionieren könnte einen einfachen Würfel erstellen, weisen das geladene Material zu dem Würfel dann ändern Sie die Renderer.sharedMaterial des Würfels anstelle von Renderer.material. In der Regel ändert das Ändern von sharedMaterial das ursprüngliche Material dauerhaft, aber ich weiß nicht, ob es für geladene Materialien von AssetDatabase gilt. Dies sollte innerhalb Ihrer OverrideMaterial Funktion erfolgen. Die Funktion GameObject.CreatePrimitive(PrimitiveType.Cube); sollte nur einmal aufgerufen werden.

GameObject cube; 
cube = GameObject.CreatePrimitive(PrimitiveType.Cube); 

Renderer cubeRenderer = cube.GetComponent<Renderer>(); 

//Change the cube material to the material that is loaded from the disk 
cubeRenderer.material = m; 

//Now modify the shared array of the cube 
cubeRenderer.sharedMaterial.SetFloat("_Mode", 3); 
cubeRenderer.sharedMaterial.SetColor("_Color", newColor); 
//cubeRenderer.sharedMaterial. 
//cubeRenderer.sharedMaterial.