C# UnityEngine.ProceduralMaterial类代码示例

    /// <summary>
    /// Gets all necessary references.
    /// </summary>
    void Start()
    {
        networkLayer = this.GetComponent<PanelNetworkLayer>();

        substance = panelBase.GetComponent<Renderer>().material as ProceduralMaterial;

        //otherPanels = GameController.instance.GetGamePanels();
    }

 /// <summary>
 /// <para>Get the ProceduralMaterial animation update rate in millisecond.</para>
 /// </summary>
 /// <param name="material"></param>
 public int GetAnimationUpdateRate(ProceduralMaterial material)
 {
     if (material == null)
     {
         throw new ArgumentException("Invalid ProceduralMaterial");
     }
     return this.GetMaterialInformation(material).animationUpdateRate;
 }

 public static int constructor(IntPtr l)
 {
     try {
         UnityEngine.ProceduralMaterial o;
         o=new UnityEngine.ProceduralMaterial();
         pushValue(l,o);
         return 1;
     }
     catch(Exception e) {
         LuaDLL.luaL_error(l, e.ToString());
         return 0;
     }
 }

 /// <summary>
 /// <para>Export a XML preset string with the value of all parameters of a given ProceduralMaterial to the specified folder.</para>
 /// </summary>
 /// <param name="material">The ProceduralMaterial whose preset string will be saved.</param>
 /// <param name="exportPath">Path to a folder where the preset file will be saved. The folder will be created if it doesn't already exist.</param>
 public void ExportPreset(ProceduralMaterial material, string exportPath)
 {
     if (material == null)
     {
         throw new ArgumentException("Invalid ProceduralMaterial");
     }
     if (exportPath == "")
     {
         throw new ArgumentException("Invalid export path specified");
     }
     if (!Directory.CreateDirectory(exportPath).Exists)
     {
         throw new ArgumentException("Export folder " + exportPath + " doesn't exist and cannot be created.");
     }
     File.WriteAllText(Path.Combine(exportPath, material.name + ".sbsprs"), material.preset);
 }

 /// <summary>
 /// <para>Export the bitmaps generated by a ProceduralMaterial as TGA files.</para>
 /// </summary>
 /// <param name="material">The ProceduralMaterial whose output textures will be saved.</param>
 /// <param name="exportPath">Path to a folder where the output bitmaps will be saved. The folder will be created if it doesn't already exist.</param>
 /// <param name="alphaRemap">Indicates whether alpha channel remapping should be performed.</param>
 public void ExportBitmaps(ProceduralMaterial material, string exportPath, bool alphaRemap)
 {
     if (material == null)
     {
         throw new ArgumentException("Invalid ProceduralMaterial");
     }
     if (exportPath == "")
     {
         throw new ArgumentException("Invalid export path specified");
     }
     if (!Directory.CreateDirectory(exportPath).Exists)
     {
         throw new ArgumentException("Export folder " + exportPath + " doesn't exist and cannot be created.");
     }
     this.ExportBitmapsInternal(material, exportPath, alphaRemap);
 }

    void OnGUI()
    {
        GUILayout.BeginArea(new Rect(10, 10, Screen.width / 6, Screen.height - 20));
        scrollViewVector = GUILayout.BeginScrollView(scrollViewVector);
        //scrollViewVector = GUI.BeginScrollView(new Rect(10, 10, Screen.width / 6, Screen.height - 20), scrollViewVector, new Rect(10, 10, Screen.width / 6, Screen.height*5));
        string[] bn = new string[buttonNames.Count()];
        for (int i = 0; i < buttonNames.Count(); i++)
        { bn[i] = buttonNames[i]; }
        button_selected = GUILayout.SelectionGrid(button_selected, bn, 1);
        GUILayout.EndScrollView();
        GUILayout.EndArea();
        //mt = Materials[button_selected];
        GUILayout.BeginArea(new Rect(Screen.width - (Screen.width / 6), 10, Screen.width / 6, Screen.height - 20));

        Object.GetComponent<Renderer>().sharedMaterial = Materials[button_selected];
        mt_proc = Object.GetComponent<Renderer>().sharedMaterial as ProceduralMaterial;
        //material_arguments.Clear();
        material_arguments = new List<ProceduralPropertyDescription>();
        material_arguments = mt_proc.GetProceduralPropertyDescriptions().Select(m => { return m; }).ToList();
        //prop_values = new float[material_arguments.Count()];
        //this.prop_values = new List<float>();
        //int ind = 0;
        GUILayout.BeginScrollView(Vector2.zero);
        foreach (ProceduralPropertyDescription desc in material_arguments)
        {
            Debug.Log(desc.GetType());
            if (desc.type == ProceduralPropertyType.Float)
            {
                //prop_values[ind] = GUILayout.HorizontalSlider(prop_values[ind], desc.minimum, desc.maximum);
                GUILayout.TextField(desc.name);
                mt_proc.SetProceduralFloat(desc.name, GUILayout.HorizontalSlider(mt_proc.GetProceduralFloat(desc.name), desc.minimum, desc.maximum));
                //ind++;
            }
            //else Debug.Log("There is no float");
        }
        GUILayout.EndScrollView();
        //foreach (var m in mt_proc.GetProceduralPropertyDescriptions()) { material_arguments.Add(m); Debug.Log(m.name); }
        //arg.Clear();
        //arg = new List<float>();
        //argument = GUILayout.HorizontalSlider(argument, 0, 1);
        //arg.Add(argument);
        //mt_proc.SetProceduralFloat("Age", argument);
        mt_proc.RebuildTextures();
        // Object.GetComponent<Renderer>().sharedMaterial = mt_proc;

        GUILayout.EndArea();
    }

 internal void DisplayRestrictedInspector()
 {
     this.m_MightHaveModified = false;
     if (this.m_Styles == null)
     {
         this.m_Styles = new Styles();
     }
     ProceduralMaterial target = base.target as ProceduralMaterial;
     if (m_Material != target)
     {
         m_Material = target;
         m_ShaderPMaterial = target.shader;
     }
     this.ProceduralProperties();
     GUILayout.Space(15f);
     this.GeneratedTextures();
 }

    // Implement your own editor GUI here.
    void OnGUI()
    {
        Objects = Selection.gameObjects as GameObject[];

        EditorGUI.LabelField(new Rect(10,10,position.width - 20, 16),"Selected Objs :", (Objects.Length).ToString());
        Mat = EditorGUI.ObjectField(new Rect(10,40,position.width - 20, 16),"Substance Mat.",Mat,typeof(ProceduralMaterial)) as ProceduralMaterial;

        if (GUI.Button(new Rect(10, 70, 50, 30), "Apply!"))
        {
            foreach(GameObject Object in Objects)
            {
                if (Object.GetComponent<Renderer>() != null)
                {
                    Object.renderer.sharedMaterial = Mat as ProceduralMaterial;
                }
            }
        }
    }

		public extern void SetTextureAlphaSource(ProceduralMaterial material, string textureName, ProceduralOutputType alphaSource);

		public void SetGenerateMipMaps(ProceduralMaterial material, bool mode)
		{
			ProceduralMaterialInformation materialInformation = this.GetMaterialInformation(material);
			materialInformation.generateMipMaps = mode;
			this.SetMaterialInformation(material, materialInformation);
		}

		public void SetAnimationUpdateRate(ProceduralMaterial material, int animation_update_rate)
		{
			ProceduralMaterialInformation materialInformation = this.GetMaterialInformation(material);
			materialInformation.animationUpdateRate = animation_update_rate;
			this.SetMaterialInformation(material, materialInformation);
		}

		public void SetGenerateAllOutputs(ProceduralMaterial material, bool generated)
		{
			ProceduralMaterialInformation materialInformation = this.GetMaterialInformation(material);
			materialInformation.generateAllOutputs = generated;
			this.SetMaterialInformation(material, materialInformation);
		}

		public void SetMaterialScale(ProceduralMaterial material, Vector2 scale)
		{
			ProceduralMaterialInformation materialInformation = this.GetMaterialInformation(material);
			materialInformation.scale = scale;
			this.SetMaterialInformation(material, materialInformation);
		}

		public void SetMaterialOffset(ProceduralMaterial material, Vector2 offset)
		{
			ProceduralMaterialInformation materialInformation = this.GetMaterialInformation(material);
			materialInformation.offset = offset;
			this.SetMaterialInformation(material, materialInformation);
		}

    //
    // This function creates a RenderToTexture for the diffuse map and stores it as a png in the Resources folders.
    //
    public void RenderDiffuse(ProceduralMaterial Diffuse, int slot)
    {
        GameObject rtObject = (GameObject)Instantiate(Resources.Load("RTTSubTerrain"));
        Camera cam = rtObject.transform.Find("RTTSubCamera").GetComponent<Camera>();

        // Create Render To Texture
        Vector2 TexSize = new Vector2((float)Math.Pow(2,Diffuse.GetProceduralVector("$outputsize").x), (float)Math.Pow(2,Diffuse.GetProceduralVector("$outputsize").y));
        RenderTexture rt = new RenderTexture((int)TexSize.x, (int)TexSize.y, 32);
        cam.targetTexture = rt;
        rtObject.transform.Find("RTTSubPlane").GetComponent<Renderer>().sharedMaterial.mainTexture = Diffuse.GetTexture ("_MainTex");
        cam.Render();
        RenderTexture.active = rt;
        Texture2D dif = new Texture2D((int)TexSize.x, (int)TexSize.y, TextureFormat.ARGB32, false);
        dif.ReadPixels(new Rect(0, 0, (int)TexSize.x, (int)TexSize.y), 0, 0);

        // Clean up
        cam.targetTexture = null;
        RenderTexture.active = null; // added to avoid errors
        DestroyImmediate(rt,true);
        DestroyImmediate(rtObject,true);

        // Write Diffuse map as PNG
          	byte[] bytes = dif.EncodeToPNG();
        string filename = Application.dataPath + "/SubTerrain/Resources/" + gameObject.name+"_splat" + slot.ToString() + ".png";
        System.IO.File.WriteAllBytes(filename, bytes);
        AssetDatabase.ImportAsset( "Assets/SubTerrain/Resources/" + gameObject.name+"_splat" + slot.ToString() + ".png" );

        DestroyImmediate(dif,true);
    }