void PropertiesGUI(int guiID)
{
scroll = GUILayout.BeginScrollView(scroll);
int i = 0;
while (i < creatureProperties.Length)
{
ProceduralPropertyDescription creatureProperty = creatureProperties[i];
ProceduralPropertyType creatureType = creatureProperties[i].type;
if (creatureProperty.hasRange)
{
if (creatureType == ProceduralPropertyType.Float)
{
GUILayout.Label(creatureProperty.name);
float creatureFloat = creatureSubstance.GetProceduralFloat(creatureProperty.name);
float oldFloat = creatureFloat;
creatureFloat = GUILayout.HorizontalSlider(creatureFloat, creatureProperty.minimum, creatureProperty.maximum);
if (creatureFloat != oldFloat)
{
creatureSubstance.SetProceduralFloat(creatureProperty.name, creatureFloat);
}
}
}
else if (creatureType == ProceduralPropertyType.Color4)
{
GUILayout.Label(creatureProperty.name);
Color creatureColor = creatureSubstance.GetProceduralColor(creatureProperty.name);
Color oldColor = creatureColor;
Rect creatureRect = GUILayoutUtility.GetLastRect();
if (GUILayout.RepeatButton(colorPicker))
{
Vector2 mousePosition = Event.current.mousePosition;
float currentPickerPosX = mousePosition.x - creatureRect.x - 10.0f;
float currentPickerPosY = (mousePosition.y - creatureRect.y + 5.0f) * (-1.0f);
int x = Convert.ToInt32(currentPickerPosX);
int y = Convert.ToInt32(currentPickerPosY);
Color col = colorPicker.GetPixel(x, y);
creatureColor = col;
}
if (creatureColor != oldColor)
{
creatureSubstance.SetProceduralColor(creatureProperty.name, creatureColor);
}
}
i++;
}
creatureSubstance.RebuildTextures();
GUILayout.EndScrollView();
}
public static void SetAllProceduralValuesToMax(SubstanceMaterialParams substanceMaterialParams) // Sets all procedural values to the maximum value
{
UnityEditor.Undo.RegisterCompleteObjectUndo(new UnityEngine.Object[] { substanceMaterialParams.substance }, "Set all values to Maximum");
for (int i = 0; i < substanceMaterialParams.materialVariables.Length; i++)
{
ProceduralPropertyDescription materialVariable = substanceMaterialParams.materialVariables[i];
if (substanceMaterialParams.substance.IsProceduralPropertyVisible(materialVariable.name))
{
ProceduralPropertyType propType = substanceMaterialParams.materialVariables[i].type;
if (propType == ProceduralPropertyType.Float)
{
substanceMaterialParams.substance.SetProceduralFloat(materialVariable.name, substanceMaterialParams.materialVariables[i].maximum);
}
if (propType == ProceduralPropertyType.Vector2 && materialVariable.hasRange)
{
substanceMaterialParams.substance.SetProceduralVector(materialVariable.name, new Vector2(substanceMaterialParams.materialVariables[i].maximum, substanceMaterialParams.materialVariables[i].maximum));
}
if (propType == ProceduralPropertyType.Vector3 && materialVariable.hasRange)
{
substanceMaterialParams.substance.SetProceduralVector(materialVariable.name, new Vector3(substanceMaterialParams.materialVariables[i].maximum, substanceMaterialParams.materialVariables[i].maximum, substanceMaterialParams.materialVariables[i].maximum));
}
if (propType == ProceduralPropertyType.Vector4 && materialVariable.hasRange)
{
substanceMaterialParams.substance.SetProceduralVector(materialVariable.name, new Vector4(substanceMaterialParams.materialVariables[i].maximum, substanceMaterialParams.materialVariables[i].maximum, substanceMaterialParams.materialVariables[i].maximum, substanceMaterialParams.materialVariables[i].maximum));
}
if (propType == ProceduralPropertyType.Enum)
{
substanceMaterialParams.substance.SetProceduralEnum(materialVariable.name, substanceMaterialParams.materialVariables[i].enumOptions.Count() - 1);
}
}
}
substanceMaterialParams.substance.RebuildTexturesImmediately();
}
static int IntToEnum(IntPtr L)
{
int arg0 = (int)LuaDLL.lua_tonumber(L, 1);
ProceduralPropertyType o = (ProceduralPropertyType)arg0;
LuaScriptMgr.PushEnum(L, o);
return(1);
}
void SetSpecificMaterialParamsAndCreateKeyframes(float keyframesToCreate, params string[] paramsNames) // needs float for division
{ // creates a certain amount of keyframes from a amount of parameter names. sets them based on
for (int i = 0; i <= keyframesToCreate - 1; i++)
{
foreach (string param in paramsNames)
{
if (testingScript.substanceMaterialParams.materialVariableNames.Contains(param))
{
int index = testingScript.substanceMaterialParams.materialVariableNames.IndexOf(param);
ProceduralPropertyDescription materialVariable = testingScript.substanceMaterialParams.materialVariables[index];
ProceduralPropertyType propType = testingScript.substanceMaterialParams.materialVariables[index].type;
if (propType == ProceduralPropertyType.Float)
{
testingScript.substanceMaterialParams.substance.SetProceduralFloat(param, (materialVariable.maximum / keyframesToCreate) * i); // set current parameter to (max value of parameter divided by the total # of keyframes to create) multiplyed by current keyframe(i)
}
else if (propType == ProceduralPropertyType.Color3)
{
testingScript.substanceMaterialParams.substance.SetProceduralColor(param, new Color(i / keyframesToCreate, 0, 0));
}
else if (propType == ProceduralPropertyType.Color4)
{
testingScript.substanceMaterialParams.substance.SetProceduralColor(param, new Color(i / keyframesToCreate, 0, 0, 254));
}
else if (propType == ProceduralPropertyType.Vector2)
{
testingScript.substanceMaterialParams.substance.SetProceduralVector(param, new Vector2(materialVariable.minimum + (materialVariable.maximum / keyframesToCreate) * i, materialVariable.minimum + (materialVariable.maximum / keyframesToCreate) * i));
}
else if (propType == ProceduralPropertyType.Vector3)
{
testingScript.substanceMaterialParams.substance.SetProceduralVector(param, new Vector3(materialVariable.minimum + (materialVariable.maximum / keyframesToCreate) * i, materialVariable.minimum + (materialVariable.maximum / keyframesToCreate) * i, materialVariable.minimum + (materialVariable.maximum / keyframesToCreate) * i));
}
else if (propType == ProceduralPropertyType.Vector4)
{
testingScript.substanceMaterialParams.substance.SetProceduralVector(param, new Vector4(materialVariable.minimum + (materialVariable.maximum / keyframesToCreate) * i, materialVariable.minimum + (materialVariable.maximum / keyframesToCreate) * i, materialVariable.minimum + (materialVariable.maximum / keyframesToCreate) * i, materialVariable.minimum + (materialVariable.maximum / keyframesToCreate) * i));
}
else if (propType == ProceduralPropertyType.Boolean)
{
if (i % 2 == 0)
{
testingScript.substanceMaterialParams.substance.SetProceduralBoolean(param, true);
}
else
{
testingScript.substanceMaterialParams.substance.SetProceduralBoolean(param, false);
}
}
else if (propType == ProceduralPropertyType.Enum)
{
testingScript.substanceMaterialParams.substance.SetProceduralEnum(param, (int)Random.Range(materialVariable.minimum, materialVariable.maximum));
}
}
//ProceduralPropertyDescription materialVariable = testingScript.substanceMaterialParams.materialVariables[ArrayUtility.IndexOf( testingScript.substanceMaterialParams.materialVariables,param)];
}
CreateKeyframe();
}
}
public static void RandomizeProceduralValues(SubstanceMaterialParams substanceMaterialParams, SubstanceRandomizeParams randomizeSettings) // Sets all procedural values to a random value
{
for (int i = 0; i < substanceMaterialParams.materialVariables.Length; i++)
{
ProceduralPropertyDescription materialVariable = substanceMaterialParams.materialVariables[i];
if (substanceMaterialParams.substance.IsProceduralPropertyVisible(materialVariable.name))
{
ProceduralPropertyType propType = substanceMaterialParams.materialVariables[i].type;
if (propType == ProceduralPropertyType.Float && materialVariable.name[0] != '$' && randomizeSettings.randomizeProceduralFloatToggle)
{
substanceMaterialParams.substance.SetProceduralFloat(materialVariable.name, UnityEngine.Random.Range(substanceMaterialParams.materialVariables[i].minimum, substanceMaterialParams.materialVariables[i].maximum));
}
if (propType == ProceduralPropertyType.Color3 && randomizeSettings.randomizeProceduralColorRGBToggle)
{
substanceMaterialParams.substance.SetProceduralColor(materialVariable.name, new Color(UnityEngine.Random.Range(0, 1f), UnityEngine.Random.Range(0, 1f), UnityEngine.Random.Range(0, 1f)));
}
if (propType == ProceduralPropertyType.Color4 && randomizeSettings.randomizeProceduralColorRGBAToggle)
{
substanceMaterialParams.substance.SetProceduralColor(materialVariable.name, new Color(UnityEngine.Random.Range(0, 1f), UnityEngine.Random.Range(0, 1f), UnityEngine.Random.Range(0, 1f), UnityEngine.Random.Range(0, 1f)));
}
if (propType == ProceduralPropertyType.Vector2 && materialVariable.name[0] != '$' && randomizeSettings.randomizeProceduralVector2Toggle)
{
substanceMaterialParams.substance.SetProceduralVector(materialVariable.name, new Vector2(UnityEngine.Random.Range(substanceMaterialParams.materialVariables[i].minimum, substanceMaterialParams.materialVariables[i].maximum), UnityEngine.Random.Range(substanceMaterialParams.materialVariables[i].minimum, substanceMaterialParams.materialVariables[i].maximum)));
}
if (propType == ProceduralPropertyType.Vector3 && randomizeSettings.randomizeProceduralVector3Toggle)
{
substanceMaterialParams.substance.SetProceduralVector(materialVariable.name, new Vector3(UnityEngine.Random.Range(substanceMaterialParams.materialVariables[i].minimum, substanceMaterialParams.materialVariables[i].maximum), UnityEngine.Random.Range(substanceMaterialParams.materialVariables[i].minimum, substanceMaterialParams.materialVariables[i].maximum), UnityEngine.Random.Range(substanceMaterialParams.materialVariables[i].minimum, substanceMaterialParams.materialVariables[i].maximum)));
}
if (propType == ProceduralPropertyType.Vector4 && randomizeSettings.randomizeProceduralVector4Toggle)
{
substanceMaterialParams.substance.SetProceduralVector(materialVariable.name, new Vector4(UnityEngine.Random.Range(substanceMaterialParams.materialVariables[i].minimum, substanceMaterialParams.materialVariables[i].maximum), UnityEngine.Random.Range(substanceMaterialParams.materialVariables[i].minimum, substanceMaterialParams.materialVariables[i].maximum), UnityEngine.Random.Range(substanceMaterialParams.materialVariables[i].minimum, substanceMaterialParams.materialVariables[i].maximum), UnityEngine.Random.Range(substanceMaterialParams.materialVariables[i].minimum, substanceMaterialParams.materialVariables[i].maximum)));
}
if (propType == ProceduralPropertyType.Enum && randomizeSettings.randomizeProceduralEnumToggle)
{
substanceMaterialParams.substance.SetProceduralEnum(materialVariable.name, UnityEngine.Random.Range(0, substanceMaterialParams.materialVariables[i].enumOptions.Count()));
}
if (propType == ProceduralPropertyType.Boolean && randomizeSettings.randomizeProceduralBooleanToggle)
{
substanceMaterialParams.substance.SetProceduralBoolean(materialVariable.name, (UnityEngine.Random.value > 0.5f));
}
}
}
substanceMaterialParams.substance.RebuildTexturesImmediately();
}
public static void SetProceduralMaterialBasedOnAnimationTime(ref float desiredTime, SubstanceMaterialParams substanceMaterialVariables, SubstanceAnimationParams substanceAnimationParams, SubstanceToolParams substanceToolParams, SubstanceFlickerParams flickerValues)
{
for (int i = 0; i <= substanceAnimationParams.substanceCurveBackup.keys.Count() - 1; i++)
{
if (substanceAnimationParams.substanceCurveBackup.keys[i].time > desiredTime) // find first key time that is greater than the desiredAnimationTime
{
float newLerp = (desiredTime - substanceAnimationParams.substanceCurveBackup.keys[i - 1].time) / (substanceAnimationParams.substanceCurveBackup.keys[i].time - substanceAnimationParams.substanceCurveBackup.keys[i - 1].time); // Finds point between two keyrames - finds percentage of desiredtime between substanceCurveBackup.keys[i - 1].time and substanceCurveBackup.keys[i].time
substanceAnimationParams.currentAnimationTime = Mathf.Lerp(0, substanceAnimationParams.keyFrameTimes[i - 1], newLerp);
substanceAnimationParams.animationTimeRestartEnd = desiredTime;
substanceAnimationParams.currentKeyframeIndex = i - 1;
if (EditorWindow.focusedWindow && EditorWindow.focusedWindow.ToString() != " (UnityEditor.CurveEditorWindow)")
{
substanceAnimationParams.lerp = newLerp;
}
for (int j = 0; j < substanceMaterialVariables.animatedMaterialVariables.Count; j++)// search through dictionary for variable names and if they match animate them
{
ProceduralPropertyDescription animatedMaterialVariable = substanceMaterialVariables.animatedMaterialVariables[j];
ProceduralPropertyType propType = substanceMaterialVariables.animatedMaterialVariables[j].type;
if (substanceMaterialVariables.materialVariableNames.Contains(animatedMaterialVariable.name))
{
if (propType == ProceduralPropertyType.Float)
{
substanceMaterialVariables.substance.SetProceduralFloat(animatedMaterialVariable.name, Mathf.Lerp(substanceMaterialVariables.MaterialVariableKeyframeDictionaryList[i - 1].PropertyFloatDictionary[animatedMaterialVariable.name], substanceMaterialVariables.MaterialVariableKeyframeDictionaryList[i].PropertyFloatDictionary[animatedMaterialVariable.name], newLerp * flickerValues.flickerFloatCalc));
}
else if (propType == ProceduralPropertyType.Color3)
{
substanceMaterialVariables.substance.SetProceduralColor(animatedMaterialVariable.name, Color.Lerp(substanceMaterialVariables.MaterialVariableKeyframeDictionaryList[i - 1].PropertyColorDictionary[animatedMaterialVariable.name], substanceMaterialVariables.MaterialVariableKeyframeDictionaryList[i].PropertyColorDictionary[animatedMaterialVariable.name], newLerp * flickerValues.flickerColor3Calc));
}
else if (propType == ProceduralPropertyType.Color4)
{
substanceMaterialVariables.substance.SetProceduralColor(animatedMaterialVariable.name, Color.Lerp(substanceMaterialVariables.MaterialVariableKeyframeDictionaryList[i - 1].PropertyColorDictionary[animatedMaterialVariable.name], substanceMaterialVariables.MaterialVariableKeyframeDictionaryList[i].PropertyColorDictionary[animatedMaterialVariable.name], newLerp * flickerValues.flickerColor4Calc));
}
else if (propType == ProceduralPropertyType.Vector2 || propType == ProceduralPropertyType.Vector3 || propType == ProceduralPropertyType.Vector4)
{
if (propType == ProceduralPropertyType.Vector4)
{
substanceMaterialVariables.substance.SetProceduralVector(animatedMaterialVariable.name, Vector4.Lerp(substanceMaterialVariables.MaterialVariableKeyframeDictionaryList[i - 1].PropertyVector4Dictionary[animatedMaterialVariable.name], substanceMaterialVariables.MaterialVariableKeyframeDictionaryList[i].PropertyVector4Dictionary[animatedMaterialVariable.name], newLerp * flickerValues.flickerVector4Calc));
}
else if (propType == ProceduralPropertyType.Vector3)
{
substanceMaterialVariables.substance.SetProceduralVector(animatedMaterialVariable.name, Vector3.Lerp(substanceMaterialVariables.MaterialVariableKeyframeDictionaryList[i - 1].PropertyVector3Dictionary[animatedMaterialVariable.name], substanceMaterialVariables.MaterialVariableKeyframeDictionaryList[i].PropertyVector3Dictionary[animatedMaterialVariable.name], newLerp * flickerValues.flickerVector3Calc));
}
else if (propType == ProceduralPropertyType.Vector2)
{
substanceMaterialVariables.substance.SetProceduralVector(animatedMaterialVariable.name, Vector2.Lerp(substanceMaterialVariables.MaterialVariableKeyframeDictionaryList[i - 1].PropertyVector2Dictionary[animatedMaterialVariable.name], substanceMaterialVariables.MaterialVariableKeyframeDictionaryList[i].PropertyVector2Dictionary[animatedMaterialVariable.name], newLerp * flickerValues.flickerVector2Calc));
}
}
else if (propType == ProceduralPropertyType.Enum)
{
substanceMaterialVariables.substance.SetProceduralEnum(animatedMaterialVariable.name, substanceMaterialVariables.MaterialVariableKeyframeDictionaryList[i - 1].PropertyEnumDictionary[animatedMaterialVariable.name]);
}
else if (propType == ProceduralPropertyType.Boolean)
{
substanceMaterialVariables.substance.SetProceduralBoolean(animatedMaterialVariable.name, substanceMaterialVariables.MaterialVariableKeyframeDictionaryList[i - 1].PropertyBoolDictionary[animatedMaterialVariable.name]);
}
}
}
if (substanceMaterialVariables.rend.sharedMaterial.HasProperty("_EmissionColor"))
{
substanceMaterialVariables.emissionInput = Color.Lerp(substanceMaterialVariables.MaterialVariableKeyframeDictionaryList[i - 1].emissionColor, substanceMaterialVariables.MaterialVariableKeyframeDictionaryList[i].emissionColor, newLerp * flickerValues.flickerCalc);
substanceMaterialVariables.rend.sharedMaterial.SetColor("_EmissionColor", substanceMaterialVariables.emissionInput);
substanceToolParams.selectedPrefabScript.emissionInput = substanceMaterialVariables.emissionInput;
}
if (substanceMaterialVariables.rend.sharedMaterial.HasProperty("_MainTex"))
{
substanceMaterialVariables.rend.sharedMaterial.SetTextureOffset("_MainTex", Vector2.Lerp(substanceMaterialVariables.MaterialVariableKeyframeDictionaryList[i - 1].MainTex, substanceMaterialVariables.MaterialVariableKeyframeDictionaryList[i].MainTex, newLerp * flickerValues.flickerCalc));
}
substanceMaterialVariables.substance.RebuildTextures();
return;
}
}
}
public void DisplaySubstanceMaterialProperties(ProceduralMaterial mySubstance)
{
ProceduralPropertyDescription[] inputs = mySubstance.GetProceduralPropertyDescriptions();
int i = 0;
while (i < inputs.Length)
{
ProceduralPropertyDescription input = inputs[i];
ProceduralPropertyType type = input.type;
//Para variables booleanas
if (type == ProceduralPropertyType.Boolean)
{
GameObject holder = GameObject.Instantiate(propertyHolderTogglePrefab, propertyParent.transform);
holder.GetComponentInChildren <Toggle>().GetComponentInChildren <Text>().text = input.label;
holder.GetComponentInChildren <Toggle>().onValueChanged.AddListener(delegate { ToggleSubtanceProperty(input.name, mySubstance, holder.GetComponentInChildren <Toggle>()); });
}
//Para variables expuestas flotantes
else if (type == ProceduralPropertyType.Float)
{
if (input.hasRange)
{
GameObject holder = GameObject.Instantiate(propertyHoldeSliderPrefab, propertyParent.transform);
holder.transform.Find("txt").GetComponent <Text>().text = input.label;
holder.GetComponentInChildren <Slider>().onValueChanged.AddListener(delegate { SlideSubstanceProperty(input, holder.GetComponentInChildren <Slider>(), mySubstance); });
}
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 = mySubstance.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)
{
mySubstance.SetProceduralVector(input.name, inputVector);
}
}
else if (type == ProceduralPropertyType.Color3 || type == ProceduralPropertyType.Color4)
{
GUILayout.Label(input.label);
int colorComponentAmount = ((type == ProceduralPropertyType.Color3) ? 3 : 4);
Color colorInput = mySubstance.GetProceduralColor(input.name);
Color oldColorInput = colorInput;
int d = 0;
while (d < colorComponentAmount)
{
colorInput[d] = GUILayout.HorizontalSlider(colorInput[d], 0, 1);
d++;
}
if (colorInput != oldColorInput)
{
mySubstance.SetProceduralColor(input.name, colorInput);
}
}
else if (type == ProceduralPropertyType.Enum)
{
GUILayout.Label(input.label);
int enumInput = mySubstance.GetProceduralEnum(input.name);
int oldEnumInput = enumInput;
string[] enumOptions = input.enumOptions;
enumInput = GUILayout.SelectionGrid(enumInput, enumOptions, 1);
if (enumInput != oldEnumInput)
{
mySubstance.SetProceduralEnum(input.name, enumInput);
}
}
}
}
i++;
}
mySubstance.RebuildTextures();
}
void ProceduralPropertiesGUI(int windowId)
{
scrolling = GUILayout.BeginScrollView(scrolling);
ProceduralMaterial substance = rend.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();
}
/// <summary>
/// Functions for storing/converting Procedural variables
/// </summary>
public static void AddProceduralVariablesToList(MaterialVariableListHolder materialVariableList, SubstanceMaterialParams substanceMaterialParams, SubstanceAnimationParams animationParams, SubstanceToolParams substanceToolParams) // Adds current procedural values to a list
{
for (int i = 0; i < substanceMaterialParams.materialVariables.Length; i++)
{
ProceduralPropertyDescription materialVariable = substanceMaterialParams.materialVariables[i];
ProceduralPropertyType propType = substanceMaterialParams.materialVariables[i].type;
if (propType != ProceduralPropertyType.Texture) // Texture Type not supported
{
materialVariableList.PropertyName.Add(materialVariable.name);
}
if (propType == ProceduralPropertyType.Float && (materialVariable.hasRange || (substanceMaterialParams.saveOutputParameters && !materialVariable.hasRange)))
{
float propFloat = substanceMaterialParams.substance.GetProceduralFloat(materialVariable.name);
materialVariableList.PropertyFloat.Add(propFloat);
materialVariableList.myFloatKeys.Add(materialVariable.name);
materialVariableList.myFloatValues.Add(propFloat);
}
else if (propType == ProceduralPropertyType.Color3 || propType == ProceduralPropertyType.Color4)
{
Color propColor = substanceMaterialParams.substance.GetProceduralColor(materialVariable.name);
materialVariableList.PropertyColor.Add(propColor);
materialVariableList.myColorKeys.Add(materialVariable.name);
materialVariableList.myColorValues.Add(propColor);
}
else if ((propType == ProceduralPropertyType.Vector2 || propType == ProceduralPropertyType.Vector3 || propType == ProceduralPropertyType.Vector4) && (materialVariable.hasRange || (substanceMaterialParams.saveOutputParameters && !materialVariable.hasRange)))
{
if (propType == ProceduralPropertyType.Vector4)
{
Vector4 propVector4 = substanceMaterialParams.substance.GetProceduralVector(materialVariable.name);
materialVariableList.PropertyVector4.Add(propVector4);
materialVariableList.myVector4Keys.Add(materialVariable.name);
materialVariableList.myVector4Values.Add(propVector4);
}
else if (propType == ProceduralPropertyType.Vector3)
{
Vector3 propVector3 = substanceMaterialParams.substance.GetProceduralVector(materialVariable.name);
materialVariableList.PropertyVector3.Add(propVector3);
materialVariableList.myVector3Keys.Add(materialVariable.name);
materialVariableList.myVector3Values.Add(propVector3);
}
else if (propType == ProceduralPropertyType.Vector2)
{
Vector2 propVector2 = substanceMaterialParams.substance.GetProceduralVector(materialVariable.name);
materialVariableList.PropertyVector2.Add(propVector2);
materialVariableList.myVector2Keys.Add(materialVariable.name);
materialVariableList.myVector2Values.Add(propVector2);
}
}
else if (propType == ProceduralPropertyType.Enum)
{
int propEnum = substanceMaterialParams.substance.GetProceduralEnum(materialVariable.name);
materialVariableList.PropertyEnum.Add(propEnum);
materialVariableList.myEnumKeys.Add(materialVariable.name);
materialVariableList.myEnumValues.Add(propEnum);
}
else if (propType == ProceduralPropertyType.Boolean)
{
bool propBool = substanceMaterialParams.substance.GetProceduralBoolean(materialVariable.name);
materialVariableList.PropertyBool.Add(propBool);
materialVariableList.myBooleanKeys.Add(materialVariable.name);
materialVariableList.myBooleanValues.Add(propBool);
}
}
materialVariableList.PropertyMaterialName = substanceMaterialParams.substance.name;
materialVariableList.emissionColor = substanceMaterialParams.emissionInput;
materialVariableList.MainTex = substanceMaterialParams.MainTexOffset;
if (substanceMaterialParams.saveOutputParameters)
{
materialVariableList.hasParametersWithoutRange = true;
}
else
{
materialVariableList.hasParametersWithoutRange = false;
}
materialVariableList.animationTime = animationParams.defaultAnimationTime;
}
public void ConvertAnimatedListToDictionaryandSet()
{
if (gameObject.GetComponent <PrefabProperties>().enabled)
{
rend = GetComponent <Renderer>();
#if UNITY_EDITOR
if (UnityEditor.Selection.activeGameObject != null && UnityEditor.Selection.activeGameObject.GetComponent <SubstanceTool>() != null)
{
useSharedMaterial = true;
}
if (UnityEditor.PrefabUtility.GetPrefabType(this) == UnityEditor.PrefabType.Prefab)
{
Debug.Log("object is in project view");
return;
}
#endif
if (useSharedMaterial && this.GetComponent <Renderer>() != null)
{
substance = rend.sharedMaterial as ProceduralMaterial;
}
else if (!useSharedMaterial && this.GetComponent <Renderer>() != null)
{
substance = rend.material as ProceduralMaterial;
}
else
{
Debug.LogWarning("No Renderer on " + this.name);
}
if (useSharedMaterial)
{
emissionInput = rend.sharedMaterial.GetColor("_EmissionColor");
}
else
{
emissionInput = rend.material.GetColor("_EmissionColor");
}
if (substance)
{
substance.cacheSize = (ProceduralCacheSize)myProceduralCacheSize;
ProceduralMaterial.substanceProcessorUsage = (ProceduralProcessorUsage)mySubstanceProcessorUsage;
substance.enableInstancing = true;
materialVariables = substance.GetProceduralPropertyDescriptions();
if (MaterialVariableKeyframeList.Count > 0)
{
for (int i = 0; i <= MaterialVariableKeyframeList.Count - 1; i++)
{
int index;
MaterialVariableKeyframeDictionaryList.Add(new MaterialVariableDictionaryHolder());
MaterialVariableKeyframeDictionaryList[i].PropertyMaterialName = MaterialVariableKeyframeList[0].PropertyMaterialName;
for (int j = 0; j < materialVariables.Length; j++)
{
ProceduralPropertyDescription materialVariable = materialVariables[j];
ProceduralPropertyType propType = materialVariables[j].type;
if (i == 0 && animatedParameterNames.Contains(materialVariable.name))
{
substance.CacheProceduralProperty(materialVariable.name, true);
}
if (propType == ProceduralPropertyType.Float)
{
if (MaterialVariableKeyframeList[i].myFloatKeys.Contains(materialVariable.name))
{
if (animatedParameterNames.Contains(materialVariable.name))
{
index = MaterialVariableKeyframeList[i].myFloatKeys.IndexOf(materialVariable.name);
float curFloat = MaterialVariableKeyframeList[i].myFloatValues[index];
MaterialVariableKeyframeDictionaryList[i].PropertyDictionary.Add(materialVariable.name, curFloat);
MaterialVariableKeyframeDictionaryList[i].PropertyFloatDictionary.Add(materialVariable.name, curFloat);
if (i == 0)
{
animatedMaterialVariables.Add(materialVariable);
}
}
if (i == 0)
{
substance.SetProceduralFloat(materialVariable.name, MaterialVariableKeyframeList[0].myFloatValues[MaterialVariableKeyframeList[0].myFloatKeys.IndexOf(materialVariable.name)]);
}
}
}
else if (propType == ProceduralPropertyType.Color3 || propType == ProceduralPropertyType.Color4)
{
if (MaterialVariableKeyframeList[i].myColorKeys.Contains(materialVariable.name))
{
if (animatedParameterNames.Contains(materialVariable.name))
{
index = MaterialVariableKeyframeList[i].myColorKeys.IndexOf(materialVariable.name);
Color curColor = MaterialVariableKeyframeList[i].myColorValues[index];
MaterialVariableKeyframeDictionaryList[i].PropertyDictionary.Add(materialVariable.name, curColor);
MaterialVariableKeyframeDictionaryList[i].PropertyColorDictionary.Add(materialVariable.name, curColor);
if (i == 0)
{
animatedMaterialVariables.Add(materialVariable);
}
}
if (i == 0)
{
substance.SetProceduralColor(materialVariable.name, MaterialVariableKeyframeList[0].myColorValues[MaterialVariableKeyframeList[0].myColorKeys.IndexOf(materialVariable.name)]);
}
}
}
else if (propType == ProceduralPropertyType.Vector2 || propType == ProceduralPropertyType.Vector3 || propType == ProceduralPropertyType.Vector4)
{
if (propType == ProceduralPropertyType.Vector4)
{
if (MaterialVariableKeyframeList[i].myVector4Keys.Contains(materialVariable.name))
{
if (animatedParameterNames.Contains(materialVariable.name))
{
index = MaterialVariableKeyframeList[i].myVector4Keys.IndexOf(materialVariable.name);
Vector4 curVector4 = MaterialVariableKeyframeList[i].myVector4Values[index];
MaterialVariableKeyframeDictionaryList[i].PropertyDictionary.Add(materialVariable.name, curVector4);
MaterialVariableKeyframeDictionaryList[i].PropertyVector4Dictionary.Add(materialVariable.name, curVector4);
if (i == 0)
{
animatedMaterialVariables.Add(materialVariable);
}
}
}
if (i == 0)
{
substance.SetProceduralVector(materialVariable.name, MaterialVariableKeyframeList[0].myVector4Values[MaterialVariableKeyframeList[0].myVector4Keys.IndexOf(materialVariable.name)]);
}
}
else if (propType == ProceduralPropertyType.Vector3)
{
if (MaterialVariableKeyframeList[i].myVector3Keys.Contains(materialVariable.name))
{
if (animatedParameterNames.Contains(materialVariable.name))
{
index = MaterialVariableKeyframeList[i].myVector3Keys.IndexOf(materialVariable.name);
Vector3 curVector3 = MaterialVariableKeyframeList[i].myVector3Values[index];
MaterialVariableKeyframeDictionaryList[i].PropertyDictionary.Add(materialVariable.name, curVector3);
MaterialVariableKeyframeDictionaryList[i].PropertyVector3Dictionary.Add(materialVariable.name, curVector3);
if (i == 0)
{
animatedMaterialVariables.Add(materialVariable);
}
}
}
if (i == 0)
{
substance.SetProceduralVector(materialVariable.name, MaterialVariableKeyframeList[0].myVector3Values[MaterialVariableKeyframeList[0].myVector3Keys.IndexOf(materialVariable.name)]);
}
}
else if (propType == ProceduralPropertyType.Vector2)
{
if (MaterialVariableKeyframeList[i].myVector2Keys.Contains(materialVariable.name))
{
if (animatedParameterNames.Contains(materialVariable.name))
{
index = MaterialVariableKeyframeList[i].myVector2Keys.IndexOf(materialVariable.name);
Vector2 curVector2 = MaterialVariableKeyframeList[i].myVector2Values[index];
MaterialVariableKeyframeDictionaryList[i].PropertyDictionary.Add(materialVariable.name, curVector2);
MaterialVariableKeyframeDictionaryList[i].PropertyVector2Dictionary.Add(materialVariable.name, curVector2);
if (i == 0)
{
animatedMaterialVariables.Add(materialVariable);
}
}
}
if (i == 0)
{
substance.SetProceduralVector(materialVariable.name, MaterialVariableKeyframeList[0].myVector2Values[MaterialVariableKeyframeList[0].myVector2Keys.IndexOf(materialVariable.name)]);
}
}
}
else if (propType == ProceduralPropertyType.Enum)
{
if (MaterialVariableKeyframeList[i].myEnumKeys.Contains(materialVariable.name))
{
if (animatedParameterNames.Contains(materialVariable.name))
{
index = MaterialVariableKeyframeList[i].myEnumKeys.IndexOf(materialVariable.name);
int curEnum = MaterialVariableKeyframeList[i].myEnumValues[index];
MaterialVariableKeyframeDictionaryList[i].PropertyDictionary.Add(materialVariable.name, curEnum);
MaterialVariableKeyframeDictionaryList[i].PropertyEnumDictionary.Add(materialVariable.name, curEnum);
if (i == 0)
{
animatedMaterialVariables.Add(materialVariable);
}
}
}
if (i == 0)
{
substance.SetProceduralEnum(materialVariable.name, MaterialVariableKeyframeList[0].myEnumValues[MaterialVariableKeyframeList[0].myEnumKeys.IndexOf(materialVariable.name)]);
}
}
else if (propType == ProceduralPropertyType.Boolean)
{
if (MaterialVariableKeyframeList[i].myBooleanKeys.Contains(materialVariable.name))
{
if (animatedParameterNames.Contains(materialVariable.name))
{
index = MaterialVariableKeyframeList[i].myBooleanKeys.IndexOf(materialVariable.name);
bool curBool = MaterialVariableKeyframeList[i].myBooleanValues[index];
MaterialVariableKeyframeDictionaryList[i].PropertyDictionary.Add(materialVariable.name, curBool);
MaterialVariableKeyframeDictionaryList[i].PropertyBoolDictionary.Add(materialVariable.name, curBool);
if (i == 0)
{
animatedMaterialVariables.Add(materialVariable);
}
}
}
if (i == 0)
{
substance.SetProceduralBoolean(materialVariable.name, MaterialVariableKeyframeList[0].myBooleanValues[MaterialVariableKeyframeList[0].myBooleanKeys.IndexOf(materialVariable.name)]);
}
}
}
MaterialVariableKeyframeDictionaryList[i].MainTex = MaterialVariableKeyframeList[i].MainTex;
MaterialVariableKeyframeDictionaryList[i].emissionColor = MaterialVariableKeyframeList[i].emissionColor;
}
}
}
if (deleteOldListValuesOnStart)
{
MaterialVariableKeyframeList.Clear();
}
}
}
void Update()
{
if (animationToggle && !isCustomInstance)
{
substance.cacheSize = (ProceduralCacheSize)myProceduralCacheSize;
if (flickerEnabled)
{
ChangeFlicker();
}
currentKeyframeAnimationTime = keyFrameTimes[currentKeyframeIndex];
if (animationType == AnimationType.BackAndForth && animateBackwards && currentKeyframeIndex <= animationEndKeyframe && currentKeyframeIndex > 0)
{
currentKeyframeAnimationTime = keyFrameTimes[currentKeyframeIndex - 1];
}
if (animateObjectBasedOnPosition != AnimateObjectBasedOnPosition.None && customObject)
{
playerDistanceToObject = Vector3.Distance(customObject.transform.position, this.transform.position);
if (animateObjectBasedOnPosition == AnimateObjectBasedOnPosition.SlowerOnApproach)
{
if (playerDistanceToObject < objectMaxDistance && playerDistanceToObject > objectMinDistance - 0.1f)
{
distanceLerpCalc = Mathf.InverseLerp(objectMaxDistance, objectMinDistance, playerDistanceToObject);
}
}
if (animateObjectBasedOnPosition == AnimateObjectBasedOnPosition.FasterOnApproach)
{
if (playerDistanceToObject < objectMaxDistance && playerDistanceToObject > objectMinDistance + 0.1f)
{
distanceLerpCalc = Mathf.InverseLerp(objectMinDistance, objectMaxDistance, playerDistanceToObject);
}
else if (playerDistanceToObject < objectMinDistance)
{
distanceLerpCalc = Mathf.InverseLerp(objectMinDistance, objectMaxDistance, objectMinDistance + 0.1f);
}
else if (playerDistanceToObject > objectMaxDistance)
{
distanceLerpCalc = Mathf.InverseLerp(objectMinDistance, objectMaxDistance, objectMaxDistance - 0.1f);
}
}
}
if (animationType == AnimationType.Loop)
{
currentKeyframeAnimationTime = keyFrameTimes[currentKeyframeIndex];
if (animateBasedOnTime)
{
currentAnimationTime += Time.deltaTime;
animationTimeRestartEnd += Time.deltaTime;
if (animateObjectBasedOnPosition != AnimateObjectBasedOnPosition.None)
{
currentAnimationTime /= distanceLerpCalc;
animationTimeRestartEnd /= Time.deltaTime;
}
}
else
{
if (animateObjectBasedOnPosition == AnimateObjectBasedOnPosition.SlowerOnApproach)
{
currentAnimationTime += distanceLerpCalc / Time.deltaTime;
animationTimeRestartEnd += distanceLerpCalc / Time.deltaTime;
}
else if (animateObjectBasedOnPosition == AnimateObjectBasedOnPosition.FasterOnApproach)
{
currentAnimationTime += Mathf.Lerp(1, 0, distanceLerpCalc) / 5;
animationTimeRestartEnd += Mathf.Lerp(1, 0, distanceLerpCalc) / 5;
}
}
curveFloat = prefabAnimationCurve.Evaluate(animationTimeRestartEnd);
if (keyFrameTimes.Count > 2 && currentAnimationTime > currentKeyframeAnimationTime && currentKeyframeIndex <= animationEndKeyframe - 2)
{
currentAnimationTime = 0;
currentKeyframeIndex++;
}
else if (keyFrameTimes.Count > 2 && currentKeyframeIndex >= animationEndKeyframe - 1)
{
currentAnimationTime = 0;
animationTimeRestartEnd = CalculateAnimationStartTime(animationStartKeyframe);
currentKeyframeIndex = animationStartKeyframe;
curveFloat = prefabAnimationCurve.Evaluate(animationTimeRestartEnd);
lerp = Mathf.InverseLerp(prefabAnimationCurve.keys[currentKeyframeIndex].time, prefabAnimationCurve.keys[currentKeyframeIndex + 1].time, curveFloat);
if (playOnce)
{
animationToggle = false;
}
}
else if (keyFrameTimes.Count == 2 && currentAnimationTime > currentKeyframeAnimationTime)
{
currentAnimationTime = 0;
animationTimeRestartEnd = 0;
currentKeyframeIndex = 0;
}
if (currentKeyframeIndex <= animationEndKeyframe - 1)
{
lerp = Mathf.InverseLerp(prefabAnimationCurve.keys[currentKeyframeIndex].time, prefabAnimationCurve.keys[currentKeyframeIndex + 1].time, curveFloat);
}
}
else if (animationType == AnimationType.BackAndForth)
{
if (animateBasedOnTime)
{
if (!animateBackwards)
{
currentAnimationTime += Time.deltaTime;
animationTimeRestartEnd += Time.deltaTime;
}
else if (animateBackwards)
{
currentAnimationTime -= Time.deltaTime;
animationTimeRestartEnd -= Time.deltaTime;
}
if (animateObjectBasedOnPosition != AnimateObjectBasedOnPosition.None)
{
currentAnimationTime /= distanceLerpCalc;
animationTimeRestartEnd /= Time.deltaTime;
}
}
else
{
if (animateObjectBasedOnPosition == AnimateObjectBasedOnPosition.SlowerOnApproach)
{
if (!animateBackwards)
{
currentAnimationTime += distanceLerpCalc / Time.deltaTime;
animationTimeRestartEnd += distanceLerpCalc / Time.deltaTime;
}
else if (animateBackwards)
{
currentAnimationTime -= distanceLerpCalc / Time.deltaTime;
animationTimeRestartEnd -= distanceLerpCalc / Time.deltaTime;
}
}
else if (animateObjectBasedOnPosition == AnimateObjectBasedOnPosition.FasterOnApproach)
{
if (!animateBackwards)
{
currentAnimationTime += Mathf.Lerp(1, 0, distanceLerpCalc) / 5;
animationTimeRestartEnd += Mathf.Lerp(1, 0, distanceLerpCalc) / 5;
}
if (animateBackwards)
{
currentAnimationTime -= Mathf.Lerp(1, 0, distanceLerpCalc) / 5;
animationTimeRestartEnd -= Mathf.Lerp(1, 0, distanceLerpCalc) / 5;
}
}
}
curveFloat = prefabAnimationCurve.Evaluate(animationTimeRestartEnd);
if (keyFrameTimes.Count > 2 && (animationEndKeyframe - 1) - animationStartKeyframe > 1 && !animateBackwards && currentAnimationTime > currentKeyframeAnimationTime && currentKeyframeIndex < animationEndKeyframe) // reach next keyframe when going forwards
{
if (currentKeyframeIndex == animationEndKeyframe - 2)
{
animateBackwards = true;
}
else
{
currentKeyframeIndex++;
currentAnimationTime = 0;
}
}
else if (keyFrameTimes.Count > 2 && animateBackwards && currentAnimationTime <= 0 && currentKeyframeIndex <= animationEndKeyframe - 1 && currentKeyframeIndex > animationStartKeyframe) // reach next keyframe when going backwards
{
currentAnimationTime = currentKeyframeAnimationTime;
currentKeyframeIndex--;
curveFloat = prefabAnimationCurve.Evaluate(animationTimeRestartEnd);
lerp = (Mathf.Lerp(1, 0, Mathf.InverseLerp(prefabAnimationCurve.keys[currentKeyframeIndex + 1].time, prefabAnimationCurve.keys[currentKeyframeIndex].time, curveFloat)));
}
else if ((keyFrameTimes.Count == 2 || (animationEndKeyframe - 1) - animationStartKeyframe == 1))
{
animateBackwards = true;
currentAnimationTime = currentKeyframeAnimationTime;
}
if (animateBackwards && currentKeyframeIndex == animationStartKeyframe && currentAnimationTime <= 0) // if you reach the last keyframe when going backwards go forwards.
{
animateBackwards = false;
currentAnimationTime = 0;
animationTimeRestartEnd = CalculateAnimationStartTime(animationStartKeyframe);
if (playOnce)
{
animationToggle = false;
}
}
if (!animateBackwards && currentKeyframeIndex < animationEndKeyframe - 1)
{
lerp = Mathf.InverseLerp(prefabAnimationCurve.keys[currentKeyframeIndex].time, prefabAnimationCurve.keys[currentKeyframeIndex + 1].time, curveFloat);
}
else if (keyFrameTimes.Count > 2 && (animationEndKeyframe - 1) - animationStartKeyframe > 1 && animateBackwards && currentAnimationTime != currentKeyframeAnimationTime && currentKeyframeIndex != animationEndKeyframe - 1)
{
lerp = (Mathf.Lerp(1, 0, Mathf.InverseLerp(prefabAnimationCurve.keys[currentKeyframeIndex + 1].time, prefabAnimationCurve.keys[currentKeyframeIndex].time, curveFloat)));
}
else if ((keyFrameTimes.Count == 2 || (animationEndKeyframe - 1) - animationStartKeyframe == 1) && animateBackwards && currentAnimationTime != currentKeyframeAnimationTime)
{
lerp = curveFloat / currentKeyframeAnimationTime;
}
}
if (materialVariables != null)
{
if (playerDistanceToObject <= LodFarDistance)
{
for (int i = 0; i < animatedMaterialVariables.Count; i++)
{
ProceduralPropertyDescription materialVariable = animatedMaterialVariables[i];
ProceduralPropertyType propType = animatedMaterialVariables[i].type;
switch (propType)
{
case ProceduralPropertyType.Float:
{
if (currentKeyframeIndex + 1 <= MaterialVariableKeyframeDictionaryList.Count - 1 && (materialVariable.name[0] != '$' || (materialVariable.name[0] == '$' && animateOutputParameters)))
{
substance.SetProceduralFloat(materialVariable.name, Mathf.Lerp(MaterialVariableKeyframeDictionaryList[currentKeyframeIndex].PropertyFloatDictionary[materialVariable.name], MaterialVariableKeyframeDictionaryList[currentKeyframeIndex + 1].PropertyFloatDictionary[materialVariable.name], lerp * flickerFloatCalc));
}
}
break;
case ProceduralPropertyType.Color3:
{
if (currentKeyframeIndex + 1 <= MaterialVariableKeyframeDictionaryList.Count - 1)
{
substance.SetProceduralColor(materialVariable.name, Color.Lerp(MaterialVariableKeyframeDictionaryList[currentKeyframeIndex].PropertyColorDictionary[materialVariable.name], MaterialVariableKeyframeDictionaryList[currentKeyframeIndex + 1].PropertyColorDictionary[materialVariable.name], lerp * flickerColor3Calc));
}
}
break;
case ProceduralPropertyType.Color4:
{
if (currentKeyframeIndex + 1 <= MaterialVariableKeyframeDictionaryList.Count - 1)
{
substance.SetProceduralColor(materialVariable.name, Color.Lerp(MaterialVariableKeyframeDictionaryList[currentKeyframeIndex].PropertyColorDictionary[materialVariable.name], MaterialVariableKeyframeDictionaryList[currentKeyframeIndex + 1].PropertyColorDictionary[materialVariable.name], lerp * flickerColor4Calc));
}
}
break;
case ProceduralPropertyType.Vector4:
{
if (currentKeyframeIndex + 1 <= MaterialVariableKeyframeDictionaryList.Count - 1)
{
substance.SetProceduralVector(materialVariable.name, Vector4.Lerp(MaterialVariableKeyframeDictionaryList[currentKeyframeIndex].PropertyVector4Dictionary[materialVariable.name], MaterialVariableKeyframeDictionaryList[currentKeyframeIndex + 1].PropertyVector4Dictionary[materialVariable.name], lerp * flickerVector4Calc));
}
}
break;
case ProceduralPropertyType.Vector3:
{
if (currentKeyframeIndex + 1 <= MaterialVariableKeyframeDictionaryList.Count - 1)
{
substance.SetProceduralVector(materialVariable.name, Vector3.Lerp(MaterialVariableKeyframeDictionaryList[currentKeyframeIndex].PropertyVector3Dictionary[materialVariable.name], MaterialVariableKeyframeDictionaryList[currentKeyframeIndex + 1].PropertyVector3Dictionary[materialVariable.name], lerp * flickerVector3Calc));
}
}
break;
case ProceduralPropertyType.Vector2:
{
if (currentKeyframeIndex + 1 <= MaterialVariableKeyframeDictionaryList.Count - 1 && (materialVariable.name[0] != '$' || (materialVariable.name[0] == '$' && animateOutputParameters)))
{
substance.SetProceduralVector(materialVariable.name, Vector2.Lerp(MaterialVariableKeyframeDictionaryList[currentKeyframeIndex].PropertyVector2Dictionary[materialVariable.name], MaterialVariableKeyframeDictionaryList[currentKeyframeIndex + 1].PropertyVector2Dictionary[materialVariable.name], lerp * flickerVector2Calc));
}
}
break;
case ProceduralPropertyType.Enum:
{
if (currentKeyframeIndex + 1 <= MaterialVariableKeyframeDictionaryList.Count - 1 && (currentAnimationTime == 0 || currentAnimationTime == currentKeyframeAnimationTime))
{
substance.SetProceduralEnum(materialVariable.name, MaterialVariableKeyframeDictionaryList[currentKeyframeIndex].PropertyEnumDictionary[materialVariable.name]);
}
}
break;
case ProceduralPropertyType.Boolean:
{
if (currentKeyframeIndex + 1 <= MaterialVariableKeyframeDictionaryList.Count - 1 && (currentAnimationTime == 0 || currentAnimationTime == currentKeyframeAnimationTime))
{
substance.SetProceduralBoolean(materialVariable.name, MaterialVariableKeyframeDictionaryList[currentKeyframeIndex].PropertyBoolDictionary[materialVariable.name]);
}
}
break;
}
}
}
if (rend.sharedMaterial.HasProperty("_EmissionColor") && currentKeyframeIndex + 1 <= MaterialVariableKeyframeDictionaryList.Count - 1)
{
rend.sharedMaterial.SetColor("_EmissionColor", Color.Lerp(MaterialVariableKeyframeDictionaryList[currentKeyframeIndex].emissionColor, MaterialVariableKeyframeDictionaryList[currentKeyframeIndex + 1].emissionColor, lerp * flickerEmissionCalc));
}
if (rend.sharedMaterial.HasProperty("_MainTex") && currentKeyframeIndex + 1 <= MaterialVariableKeyframeDictionaryList.Count - 1)
{
rend.sharedMaterial.SetTextureOffset("_MainTex", Vector2.Lerp(MaterialVariableKeyframeDictionaryList[currentKeyframeIndex].MainTex, MaterialVariableKeyframeDictionaryList[currentKeyframeIndex + 1].MainTex, lerp * flickerCalc));
}
if (playerDistanceToObject <= LodNearDistance)
{
substance.SetProceduralVector("$outputsize", originalOutputSize);
}
else if (playerDistanceToObject >= LodNearDistance && playerDistanceToObject <= LodMidDistance)
{
substance.SetProceduralVector("$outputsize", new Vector2(originalOutputSize.x - 1, originalOutputSize.y - 1));
}
else if (playerDistanceToObject >= LodMidDistance && playerDistanceToObject <= LodFarDistance)
{
substance.SetProceduralVector("$outputsize", new Vector2(originalOutputSize.x - 2, originalOutputSize.y - 2));
}
if (!rebuildSubstanceImmediately && (animateObjectBasedOnPosition == AnimateObjectBasedOnPosition.None || animateObjectBasedOnPosition != AnimateObjectBasedOnPosition.None && rend.isVisible))
{
substance.RebuildTextures();
}
else if (rebuildSubstanceImmediately && (animateObjectBasedOnPosition == AnimateObjectBasedOnPosition.None || animateObjectBasedOnPosition != AnimateObjectBasedOnPosition.None && rend.isVisible))
{
substance.RebuildTexturesImmediately();
}
}
}
}
public static void DeleteNonAnimatingParametersOnPrefab(PrefabProperties prefabProperties, SubstanceMaterialParams substanceMaterialParams, SubstanceAnimationParams animationParams)//deletes unused parameters past the first keyframe for optimizing animations for prefabs.
{
float floatValue;
Color ColorValue;
Vector2 Vector2Value;
Vector3 Vector3Value;
Vector4 Vector4Value;
bool boolValue;
int enumValue;
for (int i = 0; i < substanceMaterialParams.materialVariables.Length; i++)
{// search for variables that never change in animation and delete them from the dictionary.
ProceduralPropertyDescription MaterialVariable = substanceMaterialParams.materialVariables[i];
ProceduralPropertyType propType = substanceMaterialParams.materialVariables[i].type;
bool varChanged = false;
if (propType == ProceduralPropertyType.Float)
{
float propertyFloatAnimationCheck = 0;
for (int j = 0; j <= animationParams.keyFrameTimes.Count - 1; j++)
{
if (!varChanged && prefabProperties.MaterialVariableKeyframeList[j].myFloatKeys.Contains(substanceMaterialParams.materialVariables[i].name))
{
//MaterialVariableKeyframeDictionaryList[j].PropertyFloatDictionary.TryGetValue(materialVariables[i].name, out floatValue);
floatValue = prefabProperties.MaterialVariableKeyframeList[j].myFloatValues[prefabProperties.MaterialVariableKeyframeList[j].myFloatKeys.IndexOf(substanceMaterialParams.materialVariables[i].name)];
if (j == 0)
{
propertyFloatAnimationCheck = floatValue;
}
else if (j > 0 && floatValue != propertyFloatAnimationCheck)
{
prefabProperties.animatedParameterNames.Add(MaterialVariable.name);
varChanged = true;
}
else if (j == animationParams.keyFrameTimes.Count - 1 && floatValue == propertyFloatAnimationCheck)
{
for (int k = 1; k <= animationParams.keyFrameTimes.Count - 1; k++) // skips first keyframe
{
prefabProperties.MaterialVariableKeyframeList[k].myFloatValues.RemoveAt(prefabProperties.MaterialVariableKeyframeList[j].myFloatKeys.IndexOf(substanceMaterialParams.materialVariables[i].name));
prefabProperties.MaterialVariableKeyframeList[k].myFloatKeys.Remove(substanceMaterialParams.materialVariables[i].name);
}
}
}
}
}
else if (propType == ProceduralPropertyType.Color3 || propType == ProceduralPropertyType.Color4)
{
Color propertyColorAnimationCheck = Color.white;
for (int j = 0; j <= animationParams.keyFrameTimes.Count - 1; j++)
{
if (!varChanged && prefabProperties.MaterialVariableKeyframeList[j].myColorKeys.Contains(substanceMaterialParams.materialVariables[i].name))
{
ColorValue = prefabProperties.MaterialVariableKeyframeList[j].myColorValues[prefabProperties.MaterialVariableKeyframeList[j].myColorKeys.IndexOf(substanceMaterialParams.materialVariables[i].name)];
if (j == 0)
{
propertyColorAnimationCheck = ColorValue;
}
else if (j > 0 && ColorValue != propertyColorAnimationCheck)
{
prefabProperties.animatedParameterNames.Add(MaterialVariable.name);
varChanged = true;
}
else if (j == animationParams.keyFrameTimes.Count - 1 && ColorValue == propertyColorAnimationCheck)
{
for (int k = 1; k <= animationParams.keyFrameTimes.Count - 1; k++) // skips first keyframe
{
prefabProperties.MaterialVariableKeyframeList[k].myColorValues.RemoveAt(prefabProperties.MaterialVariableKeyframeList[j].myColorKeys.IndexOf(substanceMaterialParams.materialVariables[i].name));
prefabProperties.MaterialVariableKeyframeList[k].myColorKeys.Remove(substanceMaterialParams.materialVariables[i].name);
}
}
}
}
}
else if (propType == ProceduralPropertyType.Vector4)
{
Vector4 propertyVector4AnimationCheck = Vector4.zero;
for (int j = 0; j <= animationParams.keyFrameTimes.Count - 1; j++)
{
if (!varChanged && prefabProperties.MaterialVariableKeyframeList[j].myVector4Keys.Contains(substanceMaterialParams.materialVariables[i].name))
{
Vector4Value = prefabProperties.MaterialVariableKeyframeList[j].myVector4Values[prefabProperties.MaterialVariableKeyframeList[j].myVector4Keys.IndexOf(substanceMaterialParams.materialVariables[i].name)];
if (j == 0)
{
propertyVector4AnimationCheck = Vector4Value;
}
else if (j > 0 && Vector4Value != propertyVector4AnimationCheck)
{
prefabProperties.animatedParameterNames.Add(MaterialVariable.name);
varChanged = true;
}
else if (j == animationParams.keyFrameTimes.Count - 1 && Vector4Value == propertyVector4AnimationCheck)
{
for (int k = 1; k <= animationParams.keyFrameTimes.Count - 1; k++) // skips first keyframe
{
prefabProperties.MaterialVariableKeyframeList[k].myVector4Values.RemoveAt(prefabProperties.MaterialVariableKeyframeList[j].myVector4Keys.IndexOf(substanceMaterialParams.materialVariables[i].name));
prefabProperties.MaterialVariableKeyframeList[k].myVector4Keys.Remove(substanceMaterialParams.materialVariables[i].name);
}
}
}
}
}
else if (propType == ProceduralPropertyType.Vector3)
{
Vector3 propertyVector3AnimationCheck = Vector3.zero;
for (int j = 0; j <= animationParams.keyFrameTimes.Count - 1; j++)
{
if (!varChanged && prefabProperties.MaterialVariableKeyframeList[j].myVector3Keys.Contains(substanceMaterialParams.materialVariables[i].name))
{
Vector3Value = prefabProperties.MaterialVariableKeyframeList[j].myVector3Values[prefabProperties.MaterialVariableKeyframeList[j].myVector3Keys.IndexOf(substanceMaterialParams.materialVariables[i].name)];
if (j == 0)
{
propertyVector3AnimationCheck = Vector3Value;
}
else if (j > 0 && Vector3Value != propertyVector3AnimationCheck)
{
prefabProperties.animatedParameterNames.Add(MaterialVariable.name);
varChanged = true;
}
else if (j == animationParams.keyFrameTimes.Count - 1 && Vector3Value == propertyVector3AnimationCheck)
{
for (int k = 1; k <= animationParams.keyFrameTimes.Count - 1; k++) // skips first keyframe
{
prefabProperties.MaterialVariableKeyframeList[k].myVector3Values.RemoveAt(prefabProperties.MaterialVariableKeyframeList[j].myVector3Keys.IndexOf(substanceMaterialParams.materialVariables[i].name));
prefabProperties.MaterialVariableKeyframeList[k].myVector3Keys.Remove(substanceMaterialParams.materialVariables[i].name);
}
}
}
}
}
else if (propType == ProceduralPropertyType.Vector2)
{
Vector2 propertyVector2AnimationCheck = Vector2.zero;
for (int j = 0; j <= animationParams.keyFrameTimes.Count - 1; j++)
{
if (!varChanged && prefabProperties.MaterialVariableKeyframeList[j].myVector2Keys.Contains(substanceMaterialParams.materialVariables[i].name))
{
Vector2Value = prefabProperties.MaterialVariableKeyframeList[j].myVector2Values[prefabProperties.MaterialVariableKeyframeList[j].myVector2Keys.IndexOf(substanceMaterialParams.materialVariables[i].name)];
if (j == 0)
{
propertyVector2AnimationCheck = Vector2Value;
}
else if (j > 0 && Vector2Value != propertyVector2AnimationCheck)
{
prefabProperties.animatedParameterNames.Add(MaterialVariable.name);
varChanged = true;
}
else if (j == animationParams.keyFrameTimes.Count - 1 && Vector2Value == propertyVector2AnimationCheck)
{
for (int k = 1; k <= animationParams.keyFrameTimes.Count - 1; k++) // skips first keyframe
{
prefabProperties.MaterialVariableKeyframeList[k].myVector2Values.RemoveAt(prefabProperties.MaterialVariableKeyframeList[j].myVector2Keys.IndexOf(substanceMaterialParams.materialVariables[i].name));
prefabProperties.MaterialVariableKeyframeList[k].myVector2Keys.Remove(substanceMaterialParams.materialVariables[i].name);
}
}
}
}
}
else if (propType == ProceduralPropertyType.Enum)
{
int propertyEnumAnimationCheck = 9999;
for (int j = 0; j <= animationParams.keyFrameTimes.Count - 1; j++)
{
if (!varChanged && prefabProperties.MaterialVariableKeyframeList[j].myEnumKeys.Contains(substanceMaterialParams.materialVariables[i].name))
{
enumValue = prefabProperties.MaterialVariableKeyframeList[j].myEnumValues[prefabProperties.MaterialVariableKeyframeList[j].myEnumKeys.IndexOf(substanceMaterialParams.materialVariables[i].name)];
if (j == 0)
{
propertyEnumAnimationCheck = enumValue;
}
else if (j > 0 && enumValue != propertyEnumAnimationCheck)
{
prefabProperties.animatedParameterNames.Add(MaterialVariable.name);
varChanged = true;
}
else if (j == animationParams.keyFrameTimes.Count - 1 && enumValue == propertyEnumAnimationCheck)
{
for (int k = 1; k <= animationParams.keyFrameTimes.Count - 1; k++) // skips first keyframe
{
prefabProperties.MaterialVariableKeyframeList[k].myEnumValues.RemoveAt(prefabProperties.MaterialVariableKeyframeList[j].myEnumKeys.IndexOf(substanceMaterialParams.materialVariables[i].name));
prefabProperties.MaterialVariableKeyframeList[k].myEnumKeys.Remove(substanceMaterialParams.materialVariables[i].name);
}
}
}
}
}
else if (propType == ProceduralPropertyType.Boolean)
{
bool propertyBoolAnimationCheck = false;
for (int j = 0; j <= animationParams.keyFrameTimes.Count - 1; j++)
{
if (!varChanged && prefabProperties.MaterialVariableKeyframeList[j].myBooleanKeys.Contains(substanceMaterialParams.materialVariables[i].name))
{
boolValue = prefabProperties.MaterialVariableKeyframeList[j].myBooleanValues[prefabProperties.MaterialVariableKeyframeList[j].myBooleanKeys.IndexOf(substanceMaterialParams.materialVariables[i].name)];
if (j == 0)
{
propertyBoolAnimationCheck = boolValue;
}
else if (j > 0 && boolValue != propertyBoolAnimationCheck)
{
prefabProperties.animatedParameterNames.Add(MaterialVariable.name);
varChanged = true;
}
else if (j == animationParams.keyFrameTimes.Count - 1 && boolValue == propertyBoolAnimationCheck)
{
for (int k = 1; k <= animationParams.keyFrameTimes.Count - 1; k++) // skips first keyframe
{
prefabProperties.MaterialVariableKeyframeList[k].myBooleanValues.RemoveAt(prefabProperties.MaterialVariableKeyframeList[j].myBooleanKeys.IndexOf(substanceMaterialParams.materialVariables[i].name));
prefabProperties.MaterialVariableKeyframeList[k].myBooleanKeys.Remove(substanceMaterialParams.materialVariables[i].name);
}
}
}
}
}
}
}
public static void CacheAnimatedProceduralVariables(SubstanceMaterialParams substanceMaterialParams, SubstanceAnimationParams animationParams, bool prefab = false) //Checks which variables change throughout keyframes and add them to a list that contains animated variables.If cacheSubstance is true it will also set those variables to cache
{
if (animationParams.cacheSubstance && substanceMaterialParams.materialVariables != null)
{
substanceMaterialParams.animatedMaterialVariables.Clear(); // Makes sure if a variable stops being animatable it the list will clear and refresh later
for (int i = 0; i < substanceMaterialParams.materialVariables.Length; i++)
{
substanceMaterialParams.substance.CacheProceduralProperty(substanceMaterialParams.materialVariables[i].name, false);// Makes sure if a variable stops being animatable it the list will refresh
}
if (substanceMaterialParams.MaterialVariableKeyframeDictionaryList.Count >= 2)
{
for (int i = 0; i < substanceMaterialParams.materialVariables.Length; i++)
{
ProceduralPropertyDescription MaterialVariable = substanceMaterialParams.materialVariables[i];
ProceduralPropertyType propType = substanceMaterialParams.materialVariables[i].type;
bool varChanged = false;
if (propType == ProceduralPropertyType.Float)
{
float variableAnimationCheck = 0;
for (int j = 0; j <= animationParams.keyFrameTimes.Count - 1; j++)
{
foreach (KeyValuePair <string, float> keyValue in substanceMaterialParams.MaterialVariableKeyframeDictionaryList[j].PropertyFloatDictionary)
{
if (!varChanged && keyValue.Key == substanceMaterialParams.materialVariables[i].name)
{
if (j == 0)// find value of current parameter on first frame;
{
variableAnimationCheck = keyValue.Value;
}
else if (j > 0 && keyValue.Value != variableAnimationCheck) // if value of parameter on this keyframe is diffrent then the the value on the first keyframe.
{
substanceMaterialParams.substance.CacheProceduralProperty(keyValue.Key, true);
if (substanceMaterialParams.animatedMaterialVariables.Contains(MaterialVariable) == false)
{
substanceMaterialParams.animatedMaterialVariables.Add(MaterialVariable);
}
varChanged = true;
}
}
}
}
}
else if (propType == ProceduralPropertyType.Color3 || propType == ProceduralPropertyType.Color4)
{
Color variableAnimationCheck = Color.white;
for (int j = 0; j <= animationParams.keyFrameTimes.Count - 1; j++)
{
foreach (KeyValuePair <string, Color> keyValue in substanceMaterialParams.MaterialVariableKeyframeDictionaryList[j].PropertyColorDictionary)
{
if (!varChanged && keyValue.Key == substanceMaterialParams.materialVariables[i].name)
{
if (j == 0)
{
variableAnimationCheck = keyValue.Value;
}
else if (j > 0 && keyValue.Value != variableAnimationCheck)
{
substanceMaterialParams.substance.CacheProceduralProperty(keyValue.Key, true);
if (substanceMaterialParams.animatedMaterialVariables.Contains(MaterialVariable) == false)
{
substanceMaterialParams.animatedMaterialVariables.Add(MaterialVariable);
}
varChanged = true;
}
}
}
}
}
else if (propType == ProceduralPropertyType.Vector2)
{
Vector2 variableAnimationCheck = new Vector2(0, 0);
for (int j = 0; j <= animationParams.keyFrameTimes.Count - 1; j++)
{
foreach (KeyValuePair <string, Vector2> keyValue in substanceMaterialParams.MaterialVariableKeyframeDictionaryList[j].PropertyVector2Dictionary)
{
if (!varChanged && keyValue.Key == substanceMaterialParams.materialVariables[i].name)
{
if (j == 0)
{
variableAnimationCheck = keyValue.Value;
}
else if (j > 0 && keyValue.Value != variableAnimationCheck)
{
substanceMaterialParams.substance.CacheProceduralProperty(keyValue.Key, true);
if (substanceMaterialParams.animatedMaterialVariables.Contains(MaterialVariable) == false)
{
substanceMaterialParams.animatedMaterialVariables.Add(MaterialVariable);
}
varChanged = true;
}
}
}
}
}
else if (propType == ProceduralPropertyType.Vector3)
{
Vector3 variableAnimationCheck = new Vector3(0, 0, 0);
for (int j = 0; j <= animationParams.keyFrameTimes.Count - 1; j++)
{
foreach (KeyValuePair <string, Vector3> keyValue in substanceMaterialParams.MaterialVariableKeyframeDictionaryList[j].PropertyVector3Dictionary)
{
if (!varChanged && keyValue.Key == substanceMaterialParams.materialVariables[i].name)
{
if (j == 0)
{
variableAnimationCheck = keyValue.Value;
}
else if (j > 0 && keyValue.Value != variableAnimationCheck)
{
substanceMaterialParams.substance.CacheProceduralProperty(keyValue.Key, true);
if (substanceMaterialParams.animatedMaterialVariables.Contains(MaterialVariable) == false)
{
substanceMaterialParams.animatedMaterialVariables.Add(MaterialVariable);
}
varChanged = true;
}
}
}
}
}
else if (propType == ProceduralPropertyType.Vector4)
{
Vector4 variableAnimationCheck = new Vector4(0, 0, 0, 0);
for (int j = 0; j <= animationParams.keyFrameTimes.Count - 1; j++)
{
foreach (KeyValuePair <string, Vector4> keyValue in substanceMaterialParams.MaterialVariableKeyframeDictionaryList[j].PropertyVector4Dictionary)
{
if (!varChanged && keyValue.Key == substanceMaterialParams.materialVariables[i].name)
{
if (j == 0)
{
variableAnimationCheck = keyValue.Value;
}
else if (j > 0 && keyValue.Value != variableAnimationCheck)
{
substanceMaterialParams.substance.CacheProceduralProperty(keyValue.Key, true);
if (substanceMaterialParams.animatedMaterialVariables.Contains(MaterialVariable) == false)
{
substanceMaterialParams.animatedMaterialVariables.Add(MaterialVariable);
}
varChanged = true;
}
}
}
}
}
else if (propType == ProceduralPropertyType.Boolean)
{
bool variableAnimationCheck = false;
for (int j = 0; j <= animationParams.keyFrameTimes.Count - 1; j++)
{
foreach (KeyValuePair <string, Boolean> keyValue in substanceMaterialParams.MaterialVariableKeyframeDictionaryList[j].PropertyBoolDictionary)
{
if (!varChanged && keyValue.Key == substanceMaterialParams.materialVariables[i].name)
{
if (j == 0)
{
variableAnimationCheck = keyValue.Value;
}
else if (j > 0 && keyValue.Value != variableAnimationCheck)
{
substanceMaterialParams.substance.CacheProceduralProperty(keyValue.Key, true);
if (substanceMaterialParams.animatedMaterialVariables.Contains(MaterialVariable) == false)
{
substanceMaterialParams.animatedMaterialVariables.Add(MaterialVariable);
}
varChanged = true;
}
}
}
}
}
else if (propType == ProceduralPropertyType.Enum)
{
int variableAnimationCheck = 0;
for (int j = 0; j <= animationParams.keyFrameTimes.Count - 1; j++)
{
foreach (KeyValuePair <string, int> keyValue in substanceMaterialParams.MaterialVariableKeyframeDictionaryList[j].PropertyEnumDictionary)
{
if (!varChanged && keyValue.Key == substanceMaterialParams.materialVariables[i].name)
{
if (j == 0)
{
variableAnimationCheck = keyValue.Value;
}
else if (j > 0 && keyValue.Value != variableAnimationCheck)
{
substanceMaterialParams.substance.CacheProceduralProperty(keyValue.Key, true);
if (substanceMaterialParams.animatedMaterialVariables.Contains(MaterialVariable) == false)
{
substanceMaterialParams.animatedMaterialVariables.Add(MaterialVariable);
}
varChanged = true;
}
}
}
}
}
}
}
}
else if (!animationParams.cacheSubstance && substanceMaterialParams.materialVariables != null) // add variables if the animate but do not cache them.
{
substanceMaterialParams.animatedMaterialVariables.Clear();
for (int i = 0; i < substanceMaterialParams.materialVariables.Length; i++)
{
substanceMaterialParams.substance.CacheProceduralProperty(substanceMaterialParams.materialVariables[i].name, false);
}
if (substanceMaterialParams.MaterialVariableKeyframeDictionaryList.Count >= 2)
{
for (int i = 0; i < substanceMaterialParams.materialVariables.Length; i++)
{
ProceduralPropertyDescription MaterialVariable = substanceMaterialParams.materialVariables[i];
ProceduralPropertyType propType = substanceMaterialParams.materialVariables[i].type;
bool varChanged = false;
if (propType == ProceduralPropertyType.Float)
{
float variableAnimationCheck = 0;
for (int j = 0; j <= animationParams.keyFrameTimes.Count - 1; j++)
{
foreach (KeyValuePair <string, float> keyValue in substanceMaterialParams.MaterialVariableKeyframeDictionaryList[j].PropertyFloatDictionary)
{
if (!varChanged && keyValue.Key == substanceMaterialParams.materialVariables[i].name)
{
if (j == 0)
{
variableAnimationCheck = keyValue.Value;
}
if (j > 0 && keyValue.Value != variableAnimationCheck)
{
if (substanceMaterialParams.animatedMaterialVariables.Contains(MaterialVariable) == false)
{
substanceMaterialParams.animatedMaterialVariables.Add(MaterialVariable);
}
varChanged = true;
}
}
}
}
}
if (propType == ProceduralPropertyType.Color3 || propType == ProceduralPropertyType.Color4)
{
Color variableAnimationCheck = Color.white;
for (int j = 0; j <= animationParams.keyFrameTimes.Count - 1; j++)
{
foreach (KeyValuePair <string, Color> keyValue in substanceMaterialParams.MaterialVariableKeyframeDictionaryList[j].PropertyColorDictionary)
{
if (!varChanged && keyValue.Key == substanceMaterialParams.materialVariables[i].name)
{
if (j == 0)
{
variableAnimationCheck = keyValue.Value;
}
if (j > 0 && keyValue.Value != variableAnimationCheck)
{
if (substanceMaterialParams.animatedMaterialVariables.Contains(MaterialVariable) == false)
{
substanceMaterialParams.animatedMaterialVariables.Add(MaterialVariable);
}
varChanged = true;
}
}
}
}
}
if (propType == ProceduralPropertyType.Vector2)
{
Vector2 variableAnimationCheck = new Vector2(0, 0);
for (int j = 0; j <= animationParams.keyFrameTimes.Count - 1; j++)
{
foreach (KeyValuePair <string, Vector2> keyValue in substanceMaterialParams.MaterialVariableKeyframeDictionaryList[j].PropertyVector2Dictionary)
{
if (!varChanged && keyValue.Key == substanceMaterialParams.materialVariables[i].name)
{
if (j == 0)
{
variableAnimationCheck = keyValue.Value;
}
if (j > 0 && keyValue.Value != variableAnimationCheck)
{
if (substanceMaterialParams.animatedMaterialVariables.Contains(MaterialVariable) == false)
{
substanceMaterialParams.animatedMaterialVariables.Add(MaterialVariable);
}
varChanged = true;
}
}
}
}
}
if (propType == ProceduralPropertyType.Vector3)
{
Vector3 variableAnimationCheck = new Vector3(0, 0, 0);
for (int j = 0; j <= animationParams.keyFrameTimes.Count - 1; j++)
{
foreach (KeyValuePair <string, Vector3> keyValue in substanceMaterialParams.MaterialVariableKeyframeDictionaryList[j].PropertyVector3Dictionary)
{
if (!varChanged && keyValue.Key == substanceMaterialParams.materialVariables[i].name)
{
if (j == 0)
{
variableAnimationCheck = keyValue.Value;
}
if (j > 0 && keyValue.Value != variableAnimationCheck)
{
if (substanceMaterialParams.animatedMaterialVariables.Contains(MaterialVariable) == false)
{
substanceMaterialParams.animatedMaterialVariables.Add(MaterialVariable);
}
varChanged = true;
}
}
}
}
}
if (propType == ProceduralPropertyType.Vector4)
{
Vector4 variableAnimationCheck = new Vector4(0, 0, 0, 0);
for (int j = 0; j <= animationParams.keyFrameTimes.Count - 1; j++)
{
foreach (KeyValuePair <string, Vector4> keyValue in substanceMaterialParams.MaterialVariableKeyframeDictionaryList[j].PropertyVector4Dictionary)
{
if (!varChanged && keyValue.Key == substanceMaterialParams.materialVariables[i].name)
{
if (j == 0)
{
variableAnimationCheck = keyValue.Value;
}
if (j > 0 && keyValue.Value != variableAnimationCheck)
{
if (substanceMaterialParams.animatedMaterialVariables.Contains(MaterialVariable) == false)
{
substanceMaterialParams.animatedMaterialVariables.Add(MaterialVariable);
}
varChanged = true;
}
}
}
}
}
if (propType == ProceduralPropertyType.Boolean)
{
bool variableAnimationCheck = false;
for (int j = 0; j <= animationParams.keyFrameTimes.Count - 1; j++)
{
foreach (KeyValuePair <string, Boolean> keyValue in substanceMaterialParams.MaterialVariableKeyframeDictionaryList[j].PropertyBoolDictionary)
{
if (!varChanged && keyValue.Key == substanceMaterialParams.materialVariables[i].name)
{
if (j == 0)
{
variableAnimationCheck = keyValue.Value;
}
if (j > 0 && keyValue.Value != variableAnimationCheck)
{
if (substanceMaterialParams.animatedMaterialVariables.Contains(MaterialVariable) == false)
{
substanceMaterialParams.animatedMaterialVariables.Add(MaterialVariable);
}
varChanged = true;
}
}
}
}
}
if (propType == ProceduralPropertyType.Enum)
{
int variableAnimationCheck = 0;
for (int j = 0; j <= animationParams.keyFrameTimes.Count - 1; j++)
{
foreach (KeyValuePair <string, int> keyValue in substanceMaterialParams.MaterialVariableKeyframeDictionaryList[j].PropertyEnumDictionary)
{
if (!varChanged && keyValue.Key == substanceMaterialParams.materialVariables[i].name)
{
if (j == 0)
{
variableAnimationCheck = keyValue.Value;
}
if (j > 0 && keyValue.Value != variableAnimationCheck)
{
if (substanceMaterialParams.animatedMaterialVariables.Contains(MaterialVariable) == false)
{
substanceMaterialParams.animatedMaterialVariables.Add(MaterialVariable);
}
varChanged = true;
}
}
}
}
}
}
}
}
}
void ProceduralPropertiesGUI(int windowId)
{
scrolling = GUILayout.BeginScrollView(scrolling);
if (GUILayout.Button("Copy Preset"))
{
levelEditor.currentPreset = piece.Material.preset;
}
if (GUILayout.Button("Paste Preset"))
{
piece.Material.preset = levelEditor.currentPreset;
}
GUILayout.Space(10);
if (GUILayout.Button("Save Changes"))
{
piece.preset = piece.Material.preset;
}
if (GUILayout.Button("Revert Changes"))
{
Reload();
}
GUILayout.Space(10);
if (GUILayout.Button("Remove Piece"))
{
core.RemovePiece(piece);
}
GUILayout.Space(10);
ProceduralPropertyDescription[] inputs = piece.Material.GetProceduralPropertyDescriptions();
int i = 0;
while (i < inputs.Length)
{
ProceduralPropertyDescription input = inputs[i];
ProceduralPropertyType type = input.type;
if (type == ProceduralPropertyType.Boolean)
{
bool inputBool = piece.Material.GetProceduralBoolean(input.name);
bool oldInputBool = inputBool;
inputBool = GUILayout.Toggle(inputBool, input.name);
if (inputBool != oldInputBool)
{
piece.Material.SetProceduralBoolean(input.name, inputBool);
}
}
else if (type == ProceduralPropertyType.Float)
{
if (input.hasRange)
{
float inputFloat = piece.Material.GetProceduralFloat(input.name);
float oldInputFloat = inputFloat;
GUILayout.BeginHorizontal();
GUILayout.Label(input.name);
GUILayout.FlexibleSpace();
GUILayout.Label(inputFloat.ToString());
GUILayout.EndHorizontal();
inputFloat = GUILayout.HorizontalSlider(inputFloat, input.minimum, input.maximum);
if (inputFloat != oldInputFloat)
{
piece.Material.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 = piece.Material.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)
{
piece.Material.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 = piece.Material.GetProceduralColor(input.name);
Color oldColorInput = colorInput;
int d = 0;
while (d < colorComponentAmount)
{
GUILayout.BeginHorizontal();
var dd = "R";//ed Channel";
if (d == 1)
{
dd = "G";//reen Channel";
}
else if (d == 2)
{
dd = "B";//lue Channel";
}
else if (d == 3)
{
dd = "A";//lpha Channel";
}
GUILayout.Label(dd);
GUILayout.FlexibleSpace();
var s = Mathf.Round(float.Parse(colorInput[d].ToString()) * 255);
GUILayout.Label(s.ToString());
GUILayout.EndHorizontal();
colorInput[d] = GUILayout.HorizontalSlider(colorInput[d], 0, 1);
d++;
}
if (colorInput != oldColorInput)
{
piece.Material.SetProceduralColor(input.name, colorInput);
}
}
else if (type == ProceduralPropertyType.Enum)
{
GUILayout.Label(input.name);
int enumInput = piece.Material.GetProceduralEnum(input.name);
int oldEnumInput = enumInput;
string[] enumOptions = input.enumOptions;
enumInput = GUILayout.SelectionGrid(enumInput, enumOptions, 1);
if (enumInput != oldEnumInput)
{
piece.Material.SetProceduralEnum(input.name, enumInput);
}
}
i++;
}
piece.Material.RebuildTextures();
GUILayout.EndScrollView();
}
void VehiclePropertiesGUI(int guiID)
{
//start GUI Layout
scrollVal = GUILayout.BeginScrollView(scrollVal);
//loop through properties
int i = 0;
while (i < curProperties.Length)
{
ProceduralPropertyDescription curProperty = curProperties[i];
ProceduralPropertyType curtype = curProperties[i].type;
//create some slider for the floats
if (curtype == ProceduralPropertyType.Float)
{
if (curProperty.hasRange)
{
GUILayout.Label(curProperty.name);
float curFloat = lightcapSubstance.GetProceduralFloat(curProperty.name);
float oldFloat = curFloat;
curFloat = GUILayout.HorizontalSlider(curFloat, curProperty.minimum, curProperty.maximum);
if (curFloat != oldFloat)
{
lightcapSubstance.SetProceduralFloat(curProperty.name, curFloat);
}
}
}
else if (curtype == ProceduralPropertyType.Color4)
{
GUILayout.Label(curProperty.name);
Color curColor = lightcapSubstance.GetProceduralColor(curProperty.name);
Color oldColor = curColor;
//get the last rectangle for this picker
//Rect curRect = GUILayoutUtility.GetLastRect();
if (curColor != oldColor)
{
lightcapSubstance.SetProceduralColor(curProperty.name, curColor);
}
}
else if (curtype == ProceduralPropertyType.Enum)
{
GUILayout.Label(curProperty.name);
int enumVal = lightcapSubstance.GetProceduralEnum(curProperty.name);
int oldEnumVal = enumVal;
string[] enumOptions = curProperty.enumOptions;
enumVal = GUILayout.SelectionGrid(enumVal, enumOptions, 1);
if (enumVal != oldEnumVal)
{
lightcapSubstance.SetProceduralEnum(curProperty.name, enumVal);
}
}
i++;
}
//rebuild the substance material
lightcapSubstance.RebuildTextures();
GUILayout.EndScrollView();
}
public static void SetProceduralVariablesFromList(MaterialVariableListHolder propertyList, SubstanceMaterialParams substanceMaterialVariables, SubstanceAnimationParams substanceAnimationParams, SubstanceToolParams substanceToolParams) // Sets current substance parameters from a List
{
for (int i = 0; i < substanceMaterialVariables.materialVariables.Length; i++)
{
ProceduralPropertyDescription materialVariable = substanceMaterialVariables.materialVariables[i];
ProceduralPropertyType propType = substanceMaterialVariables.materialVariables[i].type;
if (propType == ProceduralPropertyType.Float && (materialVariable.hasRange || (substanceMaterialVariables.saveOutputParameters && !materialVariable.hasRange) || substanceMaterialVariables.resettingValuesToDefault))
{
if (propertyList.myFloatKeys.Count > 0)
{
for (int j = 0; j < propertyList.myFloatKeys.Count; j++)
{
if (propertyList.myFloatKeys[j] == materialVariable.name)
{
if (propertyList.myFloatKeys[j] == materialVariable.name)
{
substanceMaterialVariables.substance.SetProceduralFloat(materialVariable.name, propertyList.myFloatValues[j]);
}
}
}
}
else //note: for old versions of tool, remove later?
{
for (int j = 0; j < propertyList.myKeys.Count; j++)
{
if (propertyList.myKeys[j] == materialVariable.name)
{
if (propertyList.myKeys[j] == materialVariable.name)
{
substanceMaterialVariables.substance.SetProceduralFloat(materialVariable.name, float.Parse(propertyList.myValues[j]));
}
}
}
}
}
else if (propType == ProceduralPropertyType.Color3 || propType == ProceduralPropertyType.Color4)
{
if (propertyList.myColorKeys.Count > 0)
{
for (int j = 0; j < propertyList.myColorKeys.Count; j++)
{
if (propertyList.myColorKeys[j] == materialVariable.name)
{
Color curColor = propertyList.myColorValues[j];
substanceMaterialVariables.substance.SetProceduralColor(materialVariable.name, curColor);
}
}
}
else
{
for (int j = 0; j < propertyList.myKeys.Count; j++)
{
if (propertyList.myKeys[j] == materialVariable.name)
{
Color curColor;
ColorUtility.TryParseHtmlString(propertyList.myValues[j], out curColor);
substanceMaterialVariables.substance.SetProceduralColor(materialVariable.name, curColor);
}
}
}
}
else if ((propType == ProceduralPropertyType.Vector2 || propType == ProceduralPropertyType.Vector3 || propType == ProceduralPropertyType.Vector4) && (materialVariable.hasRange || (substanceMaterialVariables.saveOutputParameters && !materialVariable.hasRange) || substanceMaterialVariables.resettingValuesToDefault))
{
if (propType == ProceduralPropertyType.Vector4)
{
if (propertyList.myVector4Keys.Count > 0)
{
for (int j = 0; j < propertyList.myVector4Keys.Count; j++)
{
if (propertyList.myVector4Keys[j] == materialVariable.name)
{
Vector4 curVector4 = propertyList.myVector4Values[j];
substanceMaterialVariables.substance.SetProceduralVector(materialVariable.name, curVector4);
}
}
}
else
{
for (int j = 0; j < propertyList.myKeys.Count; j++)
{
if (propertyList.myKeys[j] == materialVariable.name)
{
Vector4 curVector4 = SubstanceTweenMiscUtility.StringToVector(propertyList.myValues[j], 4);
substanceMaterialVariables.substance.SetProceduralVector(materialVariable.name, curVector4);
}
}
}
}
else if (propType == ProceduralPropertyType.Vector3)
{
if (propertyList.myVector3Keys.Count > 0)
{
for (int j = 0; j < propertyList.myVector3Keys.Count; j++)
{
if (propertyList.myVector3Keys[j] == materialVariable.name)
{
Vector3 curVector3 = propertyList.myVector3Values[j];
substanceMaterialVariables.substance.SetProceduralVector(materialVariable.name, curVector3);
}
}
}
else
{
for (int j = 0; j < propertyList.myKeys.Count; j++)
{
if (propertyList.myKeys[j] == materialVariable.name)
{
Vector3 curVector3 = SubstanceTweenMiscUtility.StringToVector(propertyList.myValues[j], 3);
substanceMaterialVariables.substance.SetProceduralVector(materialVariable.name, curVector3);
}
}
}
}
else if (propType == ProceduralPropertyType.Vector2)
{
if (propertyList.myVector2Keys.Count > 0)
{
for (int j = 0; j < propertyList.myVector2Keys.Count; j++)
{
if (propertyList.myVector2Keys[j] == materialVariable.name)
{
Vector2 curVector2 = propertyList.myVector2Values[j];
substanceMaterialVariables.substance.SetProceduralVector(materialVariable.name, curVector2);
}
}
}
else
{
for (int j = 0; j < propertyList.myKeys.Count; j++)
{
if (propertyList.myKeys[j] == materialVariable.name)
{
Vector2 curVector2 = SubstanceTweenMiscUtility.StringToVector(propertyList.myValues[j], 2);
substanceMaterialVariables.substance.SetProceduralVector(materialVariable.name, curVector2);
}
}
}
}
}
else if (propType == ProceduralPropertyType.Enum)
{
if (propertyList.myEnumKeys.Count > 0)
{
for (int j = 0; j < propertyList.myEnumKeys.Count; j++)
{
if (propertyList.myEnumKeys[j] == materialVariable.name)
{
int curEnum = propertyList.myEnumValues[j];
substanceMaterialVariables.substance.SetProceduralEnum(materialVariable.name, curEnum);
}
}
}
else
{
for (int j = 0; j < propertyList.myKeys.Count; j++)
{
if (propertyList.myKeys[j] == materialVariable.name)
{
int curEnum = int.Parse(propertyList.myValues[j]);
substanceMaterialVariables.substance.SetProceduralEnum(materialVariable.name, curEnum);
}
}
}
}
else if (propType == ProceduralPropertyType.Boolean)
{
if (propertyList.myBooleanKeys.Count > 0)
{
for (int j = 0; j < propertyList.myBooleanKeys.Count; j++)
{
if (propertyList.myBooleanKeys[j] == materialVariable.name)
{
bool curBool = propertyList.myBooleanValues[j];
substanceMaterialVariables.substance.SetProceduralBoolean(materialVariable.name, curBool);
}
}
}
else
{
for (int j = 0; j < propertyList.myKeys.Count; j++)
{
if (propertyList.myKeys[j] == materialVariable.name)
{
bool curBool = bool.Parse(propertyList.myValues[j]);
substanceMaterialVariables.substance.SetProceduralBoolean(materialVariable.name, curBool);
}
}
}
}
}
}
void CheckForChangedMaterialParams(ProceduralPropertyDescription[] materialVariablesListBeforeChange)
{ // check if material variables have changed after the beforeChange was saved
int variablesChanged = 0;
for (int i = 0; i <= materialVariablesListBeforeChange.Count() - 1; i++)
{
ProceduralPropertyDescription materialVariableCurrent = testingScript.substanceMaterialParams.materialVariables[i];
ProceduralPropertyDescription materialVariableBeforeChange = materialVariablesListBeforeChange[i];
ProceduralPropertyType propType = testingScript.substanceMaterialParams.materialVariables[i].type;
if (propType == ProceduralPropertyType.Float)
{
float propFloatCurrent = testingScript.substanceMaterialParams.substance.GetProceduralFloat(materialVariableCurrent.name);
float propFloatBeforeChange = float.Parse(materialValuesBeforeChange[materialKeysBeforeChange.IndexOf(materialVariableCurrent.name)]);
if (propFloatCurrent != propFloatBeforeChange)
{
variablesChanged++;
}
}
else if (propType == ProceduralPropertyType.Color3 || propType == ProceduralPropertyType.Color4)
{
Color propColorCurrent = testingScript.substanceMaterialParams.substance.GetProceduralColor(materialVariableCurrent.name);
Color curColor;
ColorUtility.TryParseHtmlString(materialValuesBeforeChange[materialKeysBeforeChange.IndexOf(materialVariableCurrent.name)], out curColor);
Color propColorBeforeChange = curColor;
if (propColorCurrent != propColorBeforeChange)
{
variablesChanged++;
}
}
else if ((propType == ProceduralPropertyType.Vector2 || propType == ProceduralPropertyType.Vector3 || propType == ProceduralPropertyType.Vector4))
{
if (propType == ProceduralPropertyType.Vector4)
{
Vector4 propVector4Current = testingScript.substanceMaterialParams.substance.GetProceduralVector(materialVariableCurrent.name);
Vector4 propVector4BeforeChange = StringToVector(materialValuesBeforeChange[materialKeysBeforeChange.IndexOf(materialVariableCurrent.name)], 4);
if (propVector4Current != propVector4BeforeChange)
{
variablesChanged++;
}
}
else if (propType == ProceduralPropertyType.Vector3)
{
Vector3 propVector3Current = testingScript.substanceMaterialParams.substance.GetProceduralVector(materialVariableCurrent.name);
Vector3 propVector3BeforeChange = StringToVector(materialValuesBeforeChange[materialKeysBeforeChange.IndexOf(materialVariableCurrent.name)], 3);
if (propVector3Current != propVector3BeforeChange)
{
variablesChanged++;
}
}
else if (propType == ProceduralPropertyType.Vector2)
{
Vector2 propVector2Current = testingScript.substanceMaterialParams.substance.GetProceduralVector(materialVariableCurrent.name);
Vector2 propVector2BeforeChange = StringToVector(materialValuesBeforeChange[materialKeysBeforeChange.IndexOf(materialVariableCurrent.name)], 2);
if (propVector2Current != propVector2BeforeChange)
{
variablesChanged++;
}
}
}
else if (propType == ProceduralPropertyType.Enum)
{
int propEnumCurrent = testingScript.substanceMaterialParams.substance.GetProceduralEnum(materialVariableCurrent.name);
int propEnumBeforeChange = int.Parse(materialValuesBeforeChange[materialKeysBeforeChange.IndexOf(materialVariableCurrent.name)]);
if (propEnumCurrent != propEnumBeforeChange)
{
variablesChanged++;
}
}
else if (propType == ProceduralPropertyType.Boolean)
{
bool propBoolCurrent = testingScript.substanceMaterialParams.substance.GetProceduralBoolean(materialVariableCurrent.name);
bool propBoolBeforeChange = materialBeforeChange.GetProceduralBoolean(materialVariableBeforeChange.name);
if (propBoolCurrent != propBoolBeforeChange)
{
variablesChanged++;
}
}
if (variablesChanged > 0)
{
Assert.True(variablesChanged > 0);
break;
}
if (i == materialVariablesBeforeChange.Count() - 1 && variablesChanged == 0)
{
Assert.Fail("Material did not change");
}
}
}
public static void AddProceduralVariablesToDictionaryFromList(MaterialVariableDictionaryHolder dictionary, MaterialVariableListHolder list, ProceduralPropertyDescription[] materialVariables, bool saveOutputParameters) // sorts items from a list into a dictionary
{
if (materialVariables != null)
{
for (int i = 0; i < materialVariables.Length; i++)
{
ProceduralPropertyDescription materialVariable = materialVariables[i];
ProceduralPropertyType propType = materialVariables[i].type;
if (propType == ProceduralPropertyType.Float && (materialVariable.hasRange || (saveOutputParameters && !materialVariable.hasRange)))
{
if (!dictionary.PropertyFloatDictionary.ContainsKey(materialVariable.name))
{
dictionary.PropertyDictionary.Add(materialVariable.name, list.myFloatValues[list.myFloatKeys.IndexOf(materialVariable.name)]);
dictionary.PropertyFloatDictionary.Add(materialVariable.name, list.myFloatValues[list.myFloatKeys.IndexOf(materialVariable.name)]);
}
else // if it already contains the key overwrite it
{
dictionary.PropertyFloatDictionary[materialVariable.name] = list.myFloatValues[list.myFloatKeys.IndexOf(materialVariable.name)];
}
}
if (propType == ProceduralPropertyType.Color3 || propType == ProceduralPropertyType.Color4)
{
Color propColor = list.myColorValues[list.myColorKeys.IndexOf(materialVariable.name)];
if (!dictionary.PropertyColorDictionary.ContainsKey(materialVariable.name))
{
dictionary.PropertyDictionary.Add(materialVariable.name, propColor);
dictionary.PropertyColorDictionary.Add(materialVariable.name, propColor);
}
else
{
dictionary.PropertyColorDictionary[materialVariable.name] = propColor;
}
}
if ((propType == ProceduralPropertyType.Vector2 || propType == ProceduralPropertyType.Vector3 || propType == ProceduralPropertyType.Vector4) && (materialVariable.hasRange || (saveOutputParameters && !materialVariable.hasRange)))
{
if (propType == ProceduralPropertyType.Vector4)
{
Vector4 propVector4 = list.myVector4Values[list.myVector4Keys.IndexOf(materialVariable.name)];
if (!dictionary.PropertyVector4Dictionary.ContainsKey(materialVariable.name))
{
dictionary.PropertyDictionary.Add(materialVariable.name, propVector4);
dictionary.PropertyVector4Dictionary.Add(materialVariable.name, propVector4);
}
else
{
dictionary.PropertyVector4Dictionary[materialVariable.name] = propVector4;
}
}
else if (propType == ProceduralPropertyType.Vector3)
{
Vector3 propVector3 = list.myVector3Values[list.myVector3Keys.IndexOf(materialVariable.name)];
if (!dictionary.PropertyVector3Dictionary.ContainsKey(materialVariable.name))
{
dictionary.PropertyDictionary.Add(materialVariable.name, propVector3);
dictionary.PropertyVector3Dictionary.Add(materialVariable.name, propVector3);
}
else
{
dictionary.PropertyVector3Dictionary[materialVariable.name] = propVector3;
}
}
else if (propType == ProceduralPropertyType.Vector2)
{
Vector2 propVector2 = list.myVector2Values[list.myVector2Keys.IndexOf(materialVariable.name)];
if (!dictionary.PropertyVector2Dictionary.ContainsKey(materialVariable.name))
{
dictionary.PropertyDictionary.Add(materialVariable.name, propVector2);
dictionary.PropertyVector2Dictionary.Add(materialVariable.name, propVector2);
}
else
{
dictionary.PropertyVector2Dictionary[materialVariable.name] = propVector2;
}
}
}
if (propType == ProceduralPropertyType.Enum)
{
int propEnum = list.myEnumValues[list.myEnumKeys.IndexOf(materialVariable.name)];
if (!dictionary.PropertyEnumDictionary.ContainsKey(materialVariable.name))
{
dictionary.PropertyDictionary.Add(materialVariable.name, propEnum);
dictionary.PropertyEnumDictionary.Add(materialVariable.name, propEnum);
}
else
{
dictionary.PropertyEnumDictionary[materialVariable.name] = propEnum;
}
}
if (propType == ProceduralPropertyType.Boolean)
{
bool propBool = list.myBooleanValues[list.myBooleanKeys.IndexOf(materialVariable.name)];
if (!dictionary.PropertyBoolDictionary.ContainsKey(materialVariable.name))
{
dictionary.PropertyDictionary.Add(materialVariable.name, propBool);
dictionary.PropertyBoolDictionary.Add(materialVariable.name, propBool);
}
else
{
dictionary.PropertyBoolDictionary[materialVariable.name] = propBool;
}
}
}
dictionary.MainTex = list.MainTex;
dictionary.emissionColor = list.emissionColor;
}
}
void CheckForNoChangeInMaterialParams(ProceduralMaterial inputMaterialBeforeChange, ProceduralPropertyDescription[] materialVariablesListBeforeChange, List <string> keysList, List <string> valuesList)
{// checks if the material variables have not changed from a given material.
int variablesChanged = 0;
for (int i = 0; i <= materialVariablesListBeforeChange.Count() - 1; i++)
{
ProceduralPropertyDescription materialVariableCurrent = testingScript.substanceMaterialParams.materialVariables[i];
ProceduralPropertyDescription materialVariableBeforeChange = materialVariablesListBeforeChange[i];
ProceduralPropertyType propType = testingScript.substanceMaterialParams.materialVariables[i].type;
if (propType == ProceduralPropertyType.Float)
{
float propFloatCurrent = testingScript.substanceMaterialParams.substance.GetProceduralFloat(materialVariableCurrent.name);
float propFloatBeforeChange = float.Parse(valuesList[keysList.IndexOf(materialVariableCurrent.name)]);
if (propFloatCurrent != propFloatBeforeChange)
{
variablesChanged++;
}
}
else if (propType == ProceduralPropertyType.Color3 || propType == ProceduralPropertyType.Color4)
{
Color propColorCurrent = testingScript.substanceMaterialParams.substance.GetProceduralColor(materialVariableCurrent.name);
Color curColor;
ColorUtility.TryParseHtmlString(valuesList[keysList.IndexOf(materialVariableCurrent.name)], out curColor);
Color propColorBeforeChange = curColor;
if (propColorCurrent != propColorBeforeChange)
{
variablesChanged++;
}
}
else if ((propType == ProceduralPropertyType.Vector2 || propType == ProceduralPropertyType.Vector3 || propType == ProceduralPropertyType.Vector4))
{
if (propType == ProceduralPropertyType.Vector4)
{
Vector4 propVector4Current = testingScript.substanceMaterialParams.substance.GetProceduralVector(materialVariableCurrent.name);
Vector4 propVector4BeforeChange = StringToVector(valuesList[keysList.IndexOf(materialVariableCurrent.name)], 4);
if (propVector4Current != propVector4BeforeChange)
{
variablesChanged++;
}
}
else if (propType == ProceduralPropertyType.Vector3)
{
Vector3 propVector3Current = testingScript.substanceMaterialParams.substance.GetProceduralVector(materialVariableCurrent.name);
Vector3 propVector3BeforeChange = StringToVector(valuesList[keysList.IndexOf(materialVariableCurrent.name)], 3);
if (propVector3Current != propVector3BeforeChange)
{
variablesChanged++;
}
}
else if (propType == ProceduralPropertyType.Vector2)
{
Vector2 propVector2Current = testingScript.substanceMaterialParams.substance.GetProceduralVector(materialVariableCurrent.name);
Vector2 propVector2BeforeChange = StringToVector(valuesList[keysList.IndexOf(materialVariableCurrent.name)], 2);
if (propVector2Current != propVector2BeforeChange)
{
variablesChanged++;
}
}
}
else if (propType == ProceduralPropertyType.Enum)
{
int propEnumCurrent = testingScript.substanceMaterialParams.substance.GetProceduralEnum(materialVariableCurrent.name);
int propEnumBeforeChange = int.Parse(valuesList[keysList.IndexOf(materialVariableCurrent.name)]);
if (propEnumCurrent != propEnumBeforeChange)
{
variablesChanged++;
}
}
else if (propType == ProceduralPropertyType.Boolean)
{
bool propBoolCurrent = testingScript.substanceMaterialParams.substance.GetProceduralBoolean(materialVariableCurrent.name);
bool propBoolBeforeChange = materialBeforeChange.GetProceduralBoolean(materialVariableBeforeChange.name);
if (propBoolCurrent != propBoolBeforeChange)
{
variablesChanged++;
}
}
if (variablesChanged > 0)
{
Assert.Fail("Material not the same as original");
break;
}
if (i == materialVariablesBeforeChange.Count() - 1 && variablesChanged == 0)
{
Debug.Log("Material same as original, Success?");
}
}
}
public static void AddProceduralVariablesToDictionary(MaterialVariableDictionaryHolder materialVariableDictionary, SubstanceMaterialParams substanceMaterialParams, SubstanceAnimationParams animationParams, SubstanceToolParams substanceToolParams) // Adds current procedural values to a dictionary
{
for (int i = 0; i < substanceMaterialParams.materialVariables.Length; i++)
{
ProceduralPropertyDescription materialVariable = substanceMaterialParams.materialVariables[i];
ProceduralPropertyType propType = substanceMaterialParams.materialVariables[i].type;
if (propType != ProceduralPropertyType.Texture)
{
materialVariableDictionary.PropertyName.Add(materialVariable.name);
}
if (propType == ProceduralPropertyType.Float && (materialVariable.hasRange || (substanceMaterialParams.saveOutputParameters && !materialVariable.hasRange)))
{
float propFloat = substanceMaterialParams.substance.GetProceduralFloat(materialVariable.name);
materialVariableDictionary.PropertyDictionary.Add(materialVariable.name, propFloat);
materialVariableDictionary.PropertyFloatDictionary.Add(materialVariable.name, propFloat);
}
else if (propType == ProceduralPropertyType.Color3 || propType == ProceduralPropertyType.Color4)
{
Color propColor = substanceMaterialParams.substance.GetProceduralColor(materialVariable.name);
materialVariableDictionary.PropertyDictionary.Add(materialVariable.name, propColor);
materialVariableDictionary.PropertyColorDictionary.Add(materialVariable.name, propColor);
}
else if ((propType == ProceduralPropertyType.Vector2 || propType == ProceduralPropertyType.Vector3 || propType == ProceduralPropertyType.Vector4) && (materialVariable.hasRange || (substanceMaterialParams.saveOutputParameters && !materialVariable.hasRange)))
{
if (propType == ProceduralPropertyType.Vector4)
{
Vector4 propVector4 = substanceMaterialParams.substance.GetProceduralVector(materialVariable.name);
materialVariableDictionary.PropertyDictionary.Add(materialVariable.name, propVector4);
materialVariableDictionary.PropertyVector4Dictionary.Add(materialVariable.name, propVector4);
}
else if (propType == ProceduralPropertyType.Vector3)
{
Vector3 propVector3 = substanceMaterialParams.substance.GetProceduralVector(materialVariable.name);
materialVariableDictionary.PropertyDictionary.Add(materialVariable.name, propVector3);
materialVariableDictionary.PropertyVector3Dictionary.Add(materialVariable.name, propVector3);
}
else if (propType == ProceduralPropertyType.Vector2)
{
Vector2 propVector2 = substanceMaterialParams.substance.GetProceduralVector(materialVariable.name);
materialVariableDictionary.PropertyDictionary.Add(materialVariable.name, propVector2);
materialVariableDictionary.PropertyVector2Dictionary.Add(materialVariable.name, propVector2);
}
}
else if (propType == ProceduralPropertyType.Enum)
{
int propEnum = substanceMaterialParams.substance.GetProceduralEnum(materialVariable.name);
materialVariableDictionary.PropertyDictionary.Add(materialVariable.name, propEnum);
materialVariableDictionary.PropertyEnumDictionary.Add(materialVariable.name, propEnum);
}
else if (propType == ProceduralPropertyType.Boolean)
{
bool propBool = substanceMaterialParams.substance.GetProceduralBoolean(materialVariable.name);
materialVariableDictionary.PropertyDictionary.Add(materialVariable.name, propBool);
materialVariableDictionary.PropertyBoolDictionary.Add(materialVariable.name, propBool);
}
}
materialVariableDictionary.PropertyMaterialName = substanceMaterialParams.substance.name;
materialVariableDictionary.emissionColor = substanceMaterialParams.emissionInput;
materialVariableDictionary.MainTex = substanceMaterialParams.MainTexOffset;
if (substanceMaterialParams.saveOutputParameters)
{
materialVariableDictionary.hasParametersWithoutRange = true;
}
else
{
materialVariableDictionary.hasParametersWithoutRange = false;
}
materialVariableDictionary.animationTime = animationParams.defaultAnimationTime;
}
void AddSetProceduralVariablesBeforeChangeToKeyValue(ProceduralMaterial inputMaterialBeforeChange, ProceduralPropertyDescription[] materialVariablesListBeforeChange, List <string> keysList, List <string> valuesList)
{ // Specify current material variables as the 'beforeChange' material and what to check against after a change happens
if (keysList.Count > 0)
{
keysList.Clear();
}
if (valuesList.Count > 0)
{
valuesList.Clear();
}
for (int i = 0; i < materialVariablesBeforeChange.Length; i++)//loop through properties and make them the default properties for this object
{
ProceduralPropertyDescription materialVariable = materialVariablesBeforeChange[i];
ProceduralPropertyType propType = materialVariablesBeforeChange[i].type;
if (propType == ProceduralPropertyType.Float /*&& (materialVariable.hasRange )*/)
{
float propFloat = inputMaterialBeforeChange.GetProceduralFloat(materialVariable.name);
keysList.Add(materialVariable.name);
valuesList.Add(propFloat.ToString());
}
if (propType == ProceduralPropertyType.Color3 || propType == ProceduralPropertyType.Color4)
{
Color propColor = inputMaterialBeforeChange.GetProceduralColor(materialVariable.name);
keysList.Add(materialVariable.name);
valuesList.Add("#" + ColorUtility.ToHtmlStringRGBA(propColor));
}
if ((propType == ProceduralPropertyType.Vector2 || propType == ProceduralPropertyType.Vector3 || propType == ProceduralPropertyType.Vector4) /* && (objProperty.hasRange || (saveParametersWithoutRange && !objProperty.hasRange))*/)
{
if (propType == ProceduralPropertyType.Vector4)
{
Vector4 propVector4 = inputMaterialBeforeChange.GetProceduralVector(materialVariable.name);
keysList.Add(materialVariable.name);
valuesList.Add(propVector4.ToString());
}
else if (propType == ProceduralPropertyType.Vector3)
{
Vector3 propVector3 = inputMaterialBeforeChange.GetProceduralVector(materialVariable.name);
keysList.Add(materialVariable.name);
valuesList.Add(propVector3.ToString());
}
else if (propType == ProceduralPropertyType.Vector2)
{
Vector2 propVector2 = inputMaterialBeforeChange.GetProceduralVector(materialVariable.name);
keysList.Add(materialVariable.name);
valuesList.Add(propVector2.ToString());
}
}
else if (propType == ProceduralPropertyType.Enum)
{
int propEnum = inputMaterialBeforeChange.GetProceduralEnum(materialVariable.name);
keysList.Add(materialVariable.name);
valuesList.Add(propEnum.ToString());
}
else if (propType == ProceduralPropertyType.Boolean)
{
bool propBoolean = inputMaterialBeforeChange.GetProceduralBoolean(materialVariable.name);
keysList.Add(materialVariable.name);
valuesList.Add(propBoolean.ToString());
}
}
// materialVariables.animationTime = animationTime;
// sets a procedural material based on custom dictionary. I do this because copies of Procedural Materials get changed with their originals. This does not happen if i set values based on parsed values.
for (int i = 0; i < materialVariablesBeforeChange.Length; i++)
{
ProceduralPropertyDescription materialVariables = materialVariablesBeforeChange[i];
ProceduralPropertyType propType = materialVariablesBeforeChange[i].type;
if (propType == ProceduralPropertyType.Float && (materialVariables.hasRange /*|| (saveParametersWithoutRange && !materialVariables.hasRange) || resettingValuesToDefault)*/))
{
for (int j = 0; j < keysList.Count; j++)
{
if (keysList[j] == materialVariables.name)
{
if (keysList[j] == materialVariables.name)
{
inputMaterialBeforeChange.SetProceduralFloat(materialVariables.name, float.Parse(valuesList[j]));
}
}
}
}
else if (propType == ProceduralPropertyType.Color3 || propType == ProceduralPropertyType.Color4)
{
for (int j = 0; j < keysList.Count; j++)
{
if (keysList[j] == materialVariables.name)
{
Color curColor;
ColorUtility.TryParseHtmlString(valuesList[j], out curColor);
inputMaterialBeforeChange.SetProceduralColor(materialVariables.name, curColor);
}
}
}
else if ((propType == ProceduralPropertyType.Vector2 || propType == ProceduralPropertyType.Vector3 || propType == ProceduralPropertyType.Vector4) && (materialVariables.hasRange /*|| (saveParametersWithoutRange && !materialVariables.hasRange) || resettingValuesToDefault)*/))
{
if (propType == ProceduralPropertyType.Vector4)
{
for (int j = 0; j < keysList.Count; j++)
{
if (keysList[j] == materialVariables.name)
{
Vector4 curVector4 = StringToVector(valuesList[j], 4);
inputMaterialBeforeChange.SetProceduralVector(materialVariables.name, curVector4);
}
}
}
else if (propType == ProceduralPropertyType.Vector3)
{
for (int j = 0; j < keysList.Count; j++)
{
if (keysList[j] == materialVariables.name)
{
Vector3 curVector3 = StringToVector(valuesList[j], 3);
inputMaterialBeforeChange.SetProceduralVector(materialVariables.name, curVector3);
}
}
}
else if (propType == ProceduralPropertyType.Vector2)
{
for (int j = 0; j < keysList.Count; j++)
{
if (keysList[j] == materialVariables.name)
{
Vector2 curVector2 = StringToVector(valuesList[j], 2);
inputMaterialBeforeChange.SetProceduralVector(materialVariables.name, curVector2);
}
}
}
}
else if (propType == ProceduralPropertyType.Enum)
{
for (int j = 0; j < keysList.Count; j++)
{
if (keysList[j] == materialVariables.name)
{
int curEnum = int.Parse(valuesList[j]);
inputMaterialBeforeChange.SetProceduralEnum(materialVariables.name, curEnum);
}
}
}
else if (propType == ProceduralPropertyType.Boolean)
{
for (int j = 0; j < keysList.Count; j++)
{
if (keysList[j] == materialVariables.name)
{
bool curBool = bool.Parse(valuesList[j]);
inputMaterialBeforeChange.SetProceduralBoolean(materialVariables.name, curBool);
}
}
}
}
}