ProceduralMaterial.GetProceduralPropertyDescriptions

Description

Get an array of descriptions of all the ProceduralProperties this ProceduralMaterial has.

This can be used to build generic GUI that can be used to edit the properties of any ProceduralMaterial without knowing its properties in advance.

var scrolling : Vector2;
function OnGUI () {
	if (renderer.sharedMaterial as ProceduralMaterial) {
		// Show substance properties inside window
		var windowRect = new Rect (Screen.width-250, 30, 220, Screen.height-60);
		GUI.Window (0, windowRect, ProceduralPropertiesGUI, "Procedural Properties");
	}
}
function ProceduralPropertiesGUI (windowId : int) {	
	scrolling = GUILayout.BeginScrollView (scrolling);
	
	var substance = renderer.sharedMaterial as ProceduralMaterial;
	
	// Get a list of all the Procedural properties
	var inputs = substance.GetProceduralPropertyDescriptions ();
	// Iterate through all the properties
	for (var i : int = 0; i < inputs.Length; i++) {
		var input = inputs[i];
		
		// Handle the different types of properties
		var type = input.type;
		
		// Show a boolean as a toggle
		if (type == ProceduralPropertyType.Boolean) {
			var inputBool = substance.GetProceduralBoolean (input.name);
			var oldInputBool = inputBool;
			inputBool = GUILayout.Toggle (inputBool, input.name);
			if (inputBool != oldInputBool)
				substance.SetProceduralBoolean (input.name, inputBool);
		}
		// Show a float as a slider
		else if (type == ProceduralPropertyType.Float) {
			// Only show GUI for numbers with a defined range
			if (input.hasRange) {
				GUILayout.Label (input.name);
				
				var inputFloat = substance.GetProceduralFloat (input.name);
				var oldInputFloat = inputFloat;
				
				inputFloat = GUILayout.HorizontalSlider (inputFloat, input.minimum, input.maximum);
				if (inputFloat != oldInputFloat)
					substance.SetProceduralFloat (input.name, inputFloat);
			}
		}
		// Show a vector as multiple sliders
		else if (type == ProceduralPropertyType.Vector2 ||
			type == ProceduralPropertyType.Vector3 ||
			type == ProceduralPropertyType.Vector4
		) {
			// Only show GUI for numbers with a defined range
			if (input.hasRange) {
				GUILayout.Label (input.name);
				
				// How many components are in this vector?
				var vectorComponentAmount = 4;
				if (type == ProceduralPropertyType.Vector2) vectorComponentAmount = 2;
				if (type == ProceduralPropertyType.Vector3) vectorComponentAmount = 3;
				
				var inputVector = substance.GetProceduralVector (input.name);
				var oldInputVector = inputVector;
				
				// Loop through the vector component and show a slider for each
				for (var c : int = 0; c < vectorComponentAmount; c++)
					inputVector[c] = GUILayout.HorizontalSlider (
						inputVector[c], input.minimum, input.maximum);
				
				if (inputVector != oldInputVector)
					substance.SetProceduralVector (input.name, inputVector);
			}
		}
		// Show a color as multiple sliders
		else if (type == ProceduralPropertyType.Color3 || type == ProceduralPropertyType.Color4) {
			GUILayout.Label (input.name);
			
			// How many numbers are in this color?
			var colorComponentAmount = (type == ProceduralPropertyType.Color3 ? 3 : 4);
			
			var colorInput = substance.GetProceduralColor (input.name);
			var oldColorInput = colorInput;
			
			// Loop through the vector numbers and show a slider for each
			for (var d : int = 0; d < colorComponentAmount; d++)
				colorInput[d] = GUILayout.HorizontalSlider (colorInput[d], 0, 1);
			
			if (colorInput != oldColorInput)
				substance.SetProceduralColor (input.name, colorInput);
		}
		
		// Show an enum as a selection grid
		else if (type == ProceduralPropertyType.Enum) {
			GUILayout.Label (input.name);
			
			var enumInput = substance.GetProceduralEnum (input.name);
			var oldEnumInput = enumInput;
			var enumOptions = input.enumOptions;
			
			enumInput = GUILayout.SelectionGrid (enumInput, enumOptions, 1);
			if (enumInput != oldEnumInput)
				substance.SetProceduralEnum (input.name, enumInput);
		}
	}
	// Rebuild the textures to show the changes
	substance.RebuildTextures();
	
	GUILayout.EndScrollView();
}

using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    public Vector2 scrolling;
    void OnGUI() {
        if (renderer.sharedMaterial as ProceduralMaterial) {
            Rect windowRect = new Rect(Screen.width - 250, 30, 220, Screen.height - 60);
            GUI.Window(0, windowRect, ProceduralPropertiesGUI, "Procedural Properties");
        }
    }
    void ProceduralPropertiesGUI(int windowId) {
        scrolling = GUILayout.BeginScrollView(scrolling);
        ProceduralMaterial substance = renderer.sharedMaterial as ProceduralMaterial;
        ProceduralPropertyDescription[] inputs = substance.GetProceduralPropertyDescriptions();
        int i = 0;
        while (i < inputs.Length) {
            ProceduralPropertyDescription input = inputs[i];
            ProceduralPropertyType type = input.type;
            if (type == ProceduralPropertyType.Boolean) {
                bool inputBool = substance.GetProceduralBoolean(input.name);
                bool oldInputBool = inputBool;
                inputBool = GUILayout.Toggle(inputBool, input.name);
                if (inputBool != oldInputBool)
                    substance.SetProceduralBoolean(input.name, inputBool);
                
            } else
                if (type == ProceduralPropertyType.Float)
                    if (input.hasRange) {
                        GUILayout.Label(input.name);
                        float inputFloat = substance.GetProceduralFloat(input.name);
                        float oldInputFloat = inputFloat;
                        inputFloat = GUILayout.HorizontalSlider(inputFloat, input.minimum, input.maximum);
                        if (inputFloat != oldInputFloat)
                            substance.SetProceduralFloat(input.name, inputFloat);
                        
                    }
                else
                    if (type == ProceduralPropertyType.Vector2 || type == ProceduralPropertyType.Vector3 || type == ProceduralPropertyType.Vector4)
                        if (input.hasRange) {
                            GUILayout.Label(input.name);
                            int vectorComponentAmount = 4;
                            if (type == ProceduralPropertyType.Vector2)
                                vectorComponentAmount = 2;
                            
                            if (type == ProceduralPropertyType.Vector3)
                                vectorComponentAmount = 3;
                            
                            Vector4 inputVector = substance.GetProceduralVector(input.name);
                            Vector4 oldInputVector = inputVector;
                            int c = 0;
                            while (c < vectorComponentAmount) {
                                inputVector[c] = GUILayout.HorizontalSlider(inputVector[c], input.minimum, input.maximum);
                                c++;
                            }
                            if (inputVector != oldInputVector)
                                substance.SetProceduralVector(input.name, inputVector);
                            
                        }
                    else
                        if (type == ProceduralPropertyType.Color3 || type == ProceduralPropertyType.Color4) {
                            GUILayout.Label(input.name);
                            int colorComponentAmount = ((type == ProceduralPropertyType.Color3) ? 3 : 4);
                            Color colorInput = substance.GetProceduralColor(input.name);
                            Color oldColorInput = colorInput;
                            int d = 0;
                            while (d < colorComponentAmount) {
                                colorInput[d] = GUILayout.HorizontalSlider(colorInput[d], 0, 1);
                                d++;
                            }
                            if (colorInput != oldColorInput)
                                substance.SetProceduralColor(input.name, colorInput);
                            
                        } else
                            if (type == ProceduralPropertyType.Enum) {
                                GUILayout.Label(input.name);
                                int enumInput = substance.GetProceduralEnum(input.name);
                                int oldEnumInput = enumInput;
                                string[] enumOptions = input.enumOptions;
                                enumInput = GUILayout.SelectionGrid(enumInput, enumOptions, 1);
                                if (enumInput != oldEnumInput)
                                    substance.SetProceduralEnum(input.name, enumInput);
                                
                            }
            i++;
        }
        substance.RebuildTextures();
        GUILayout.EndScrollView();
    }
}

import UnityEngine
import System.Collections

public class ExampleClass(MonoBehaviour):

	public scrolling as Vector2

	def OnGUI() as void:
		if (renderer.sharedMaterial as ProceduralMaterial):
			windowRect as Rect = Rect((Screen.width - 250), 30, 220, (Screen.height - 60))
			GUI.Window(0, windowRect, ProceduralPropertiesGUI, 'Procedural Properties')

	def ProceduralPropertiesGUI(windowId as int) as void:
		scrolling = GUILayout.BeginScrollView(scrolling)
		substance as ProceduralMaterial = (renderer.sharedMaterial as ProceduralMaterial)
		inputs as (ProceduralPropertyDescription) = substance.GetProceduralPropertyDescriptions()
		i as int = 0
		while i < inputs.Length:
			input as ProceduralPropertyDescription = inputs[i]
			type as ProceduralPropertyType = input.type
			if type == ProceduralPropertyType.Boolean:
				inputBool as bool = substance.GetProceduralBoolean(input.name)
				oldInputBool as bool = inputBool
				inputBool = GUILayout.Toggle(inputBool, input.name)
				if inputBool != oldInputBool:
					substance.SetProceduralBoolean(input.name, inputBool)
			elif type == ProceduralPropertyType.Float:
				if input.hasRange:
					GUILayout.Label(input.name)
					inputFloat as float = substance.GetProceduralFloat(input.name)
					oldInputFloat as float = inputFloat
					inputFloat = GUILayout.HorizontalSlider(inputFloat, input.minimum, input.maximum)
					if inputFloat != oldInputFloat:
						substance.SetProceduralFloat(input.name, inputFloat)
			elif ((type == ProceduralPropertyType.Vector2) or (type == ProceduralPropertyType.Vector3)) or (type == ProceduralPropertyType.Vector4):
				if input.hasRange:
					GUILayout.Label(input.name)
					vectorComponentAmount as int = 4
					if type == ProceduralPropertyType.Vector2:
						vectorComponentAmount = 2
					if type == ProceduralPropertyType.Vector3:
						vectorComponentAmount = 3
					inputVector as Vector4 = substance.GetProceduralVector(input.name)
					oldInputVector as Vector4 = inputVector
					c as int = 0
					while c < vectorComponentAmount:
						inputVector[c] = GUILayout.HorizontalSlider(inputVector[c], input.minimum, input.maximum)
						c++
					if inputVector != oldInputVector:
						substance.SetProceduralVector(input.name, inputVector)
			elif (type == ProceduralPropertyType.Color3) or (type == ProceduralPropertyType.Color4):
				GUILayout.Label(input.name)
				colorComponentAmount as int = (3 if (type == ProceduralPropertyType.Color3) else 4)
				colorInput as Color = substance.GetProceduralColor(input.name)
				oldColorInput as Color = colorInput
				d as int = 0
				while d < colorComponentAmount:
					colorInput[d] = GUILayout.HorizontalSlider(colorInput[d], 0, 1)
					d++
				if colorInput != oldColorInput:
					substance.SetProceduralColor(input.name, colorInput)
			elif type == ProceduralPropertyType.Enum:
				GUILayout.Label(input.name)
				enumInput as int = substance.GetProceduralEnum(input.name)
				oldEnumInput as int = enumInput
				enumOptions as (string) = input.enumOptions
				enumInput = GUILayout.SelectionGrid(enumInput, enumOptions, 1)
				if enumInput != oldEnumInput:
					substance.SetProceduralEnum(input.name, enumInput)
			i++
		substance.RebuildTextures()
		GUILayout.EndScrollView()