public static void DeleteKeyframe(int index, SubstanceMaterialParams substanceMaterialParams, SubstanceAnimationParams animationParams)
{
List <Keyframe> tmpKeyframeList = animationParams.substanceCurve.keys.ToList();
animationParams.keyFrameTimes.RemoveAt(index);
substanceMaterialParams.MaterialVariableKeyframeList.RemoveAt(index);
substanceMaterialParams.MaterialVariableKeyframeDictionaryList.RemoveAt(index);
animationParams.keyframeSum = 0;
for (int i = substanceMaterialParams.MaterialVariableKeyframeList.Count(); i >= 0; i--)
{
animationParams.substanceCurve.RemoveKey(i);
}
for (int i = 0; i <= substanceMaterialParams.MaterialVariableKeyframeList.Count() - 1; i++)
{
animationParams.substanceCurve.AddKey(new Keyframe(animationParams.keyframeSum, animationParams.keyframeSum, tmpKeyframeList[i].inTangent, tmpKeyframeList[i].outTangent));
animationParams.keyframeSum += animationParams.keyFrameTimes[i];
}
;
animationParams.currentAnimationTime = 0;
animationParams.currentKeyframeIndex = 0;
animationParams.animationTimeRestartEnd = 0;
animationParams.keyframeSum = 0;
if (animationParams.keyFrames > 0)
{
animationParams.keyFrames--;
}
animationParams.substanceCurveBackup.keys = animationParams.substanceCurve.keys;
SubstanceTweenAnimationUtility.CacheAnimatedProceduralVariables(substanceMaterialParams, animationParams);
SubstanceTweenAnimationUtility.CalculateAnimationLength(substanceMaterialParams, animationParams);
}
public static void CreateKeyframe(SubstanceMaterialParams substanceMaterialParams, SubstanceAnimationParams animationParams, SubstanceToolParams substanceToolParams)
{
//UnityEditor.Undo.RegisterCompleteObjectUndo(new UnityEngine.Object[] { substanceMaterialParams.substance, substanceToolParams.currentSelection }, "Create Keyframe " + substanceMaterialParams.MaterialVariableKeyframeDictionaryList.Count().ToString());
if (animationParams.keyFrameTimes.Count == 0)
{
substanceToolParams.DebugStrings.Add("Created Keyframe 1:");
substanceMaterialParams.MaterialVariableKeyframeDictionaryList.Add(new MaterialVariableDictionaryHolder());
substanceMaterialParams.MaterialVariableKeyframeList.Add(new MaterialVariableListHolder());
SubstanceTweenStorageUtility.AddProceduralVariablesToList(substanceMaterialParams.MaterialVariableKeyframeList[0], substanceMaterialParams, animationParams, substanceToolParams);
SubstanceTweenStorageUtility.AddProceduralVariablesToDictionary(substanceMaterialParams.MaterialVariableKeyframeDictionaryList[0], substanceMaterialParams, animationParams, substanceToolParams);
animationParams.keyFrames++;
animationParams.keyFrameTimes.Add(substanceMaterialParams.MaterialVariableKeyframeList[0].animationTime);
animationParams.substanceCurve.AddKey(new Keyframe(substanceMaterialParams.MaterialVariableKeyframeList[0].animationTime, substanceMaterialParams.MaterialVariableKeyframeList[0].animationTime));
UnityEditor.AnimationUtility.SetKeyLeftTangentMode(animationParams.substanceCurve, 0, UnityEditor.AnimationUtility.TangentMode.Linear);
UnityEditor.AnimationUtility.SetKeyRightTangentMode(animationParams.substanceCurve, 0, UnityEditor.AnimationUtility.TangentMode.Linear);
}
else if (animationParams.keyFrameTimes.Count > 0)
{
for (int i = 0; i <= animationParams.keyFrameTimes.Count - 1; i++)
{ // Goes through each key frame and checks if the keyframe that you are trying to create has the same number of parameters as the rest and if they all save Output parameters or not.
if (substanceMaterialParams.saveOutputParameters && substanceMaterialParams.MaterialVariableKeyframeList[i].hasParametersWithoutRange == false)
{ //Subsance designer can export special properties like '$randomSeed' that can be saved. this checks if you selected to save those objects and turned it off later
UnityEditor.EditorUtility.DisplayDialog("Error", "Could not save keyframe because you are saving Parameters without a range however keyframe " + (i + 1) + " does " +
"not save these variables. To fix this uncheck \"Save Output Parameters\" on this frame and try again or check \"Save Output Parameters\" then select and overWrite on every other frame. ", "OK");
return;
}
if (!substanceMaterialParams.saveOutputParameters && substanceMaterialParams.MaterialVariableKeyframeList[i].hasParametersWithoutRange == true)
{
UnityEditor.EditorUtility.DisplayDialog("Error", "Could not save keyframe because you are not saving Parameters without a range however keyframe " + i + " does " +
"save these variables. To fix this check \"Save Output Parameters\" on this frame and try again or uncheck \"Save Output Parameters\" then select and overWrite on every other frame. ", "OK");
return;
}
}
substanceMaterialParams.MaterialVariableKeyframeList.Add(new MaterialVariableListHolder());
substanceToolParams.DebugStrings.Add("Created KeyFrame: " + substanceMaterialParams.MaterialVariableKeyframeList.Count);
substanceMaterialParams.MaterialVariableKeyframeDictionaryList.Add(new MaterialVariableDictionaryHolder());
SubstanceTweenStorageUtility.AddProceduralVariablesToList(substanceMaterialParams.MaterialVariableKeyframeList[animationParams.keyFrames], substanceMaterialParams, animationParams, substanceToolParams);
SubstanceTweenStorageUtility.AddProceduralVariablesToDictionary(substanceMaterialParams.MaterialVariableKeyframeDictionaryList[animationParams.keyFrames], substanceMaterialParams, animationParams, substanceToolParams);
animationParams.keyFrameTimes.Add(substanceMaterialParams.MaterialVariableKeyframeList[animationParams.keyFrames].animationTime);
animationParams.keyframeSum = 0;
for (int i = 0; i < substanceMaterialParams.MaterialVariableKeyframeList.Count() - 1; i++)
{
animationParams.keyframeSum += substanceMaterialParams.MaterialVariableKeyframeList[i].animationTime;
}
animationParams.substanceCurve.AddKey(new Keyframe(animationParams.keyframeSum, animationParams.keyframeSum));
if (animationParams.keyFrames > 0)
{
UnityEditor.AnimationUtility.SetKeyLeftTangentMode(animationParams.substanceCurve, animationParams.keyFrames, UnityEditor.AnimationUtility.TangentMode.Linear);
}
UnityEditor.AnimationUtility.SetKeyRightTangentMode(animationParams.substanceCurve, animationParams.keyFrames, UnityEditor.AnimationUtility.TangentMode.Linear);
animationParams.keyFrames++;
}
animationParams.substanceCurveBackup.keys = animationParams.substanceCurve.keys;
substanceToolParams.lastAction = MethodBase.GetCurrentMethod().Name.ToString();
SubstanceTweenAnimationUtility.CacheAnimatedProceduralVariables(substanceMaterialParams, animationParams);
SubstanceTweenAnimationUtility.CalculateAnimationLength(substanceMaterialParams, animationParams);
}
public static void SelectAndOverWriteAllKeyframes(SubstanceMaterialParams substanceMaterialParams, SubstanceAnimationParams animationParams, SubstanceToolParams substanceToolParams)
{
animationParams.keyframeSum = 0;
for (int i = 0; i <= substanceMaterialParams.MaterialVariableKeyframeList.Count() - 1; i++)
{
SubstanceTweenKeyframeUtility.SelectKeyframe(i, substanceMaterialParams, animationParams, substanceToolParams);
SubstanceTweenKeyframeUtility.OverWriteKeyframe(i, substanceMaterialParams, animationParams, substanceToolParams);
animationParams.keyframeSum += animationParams.keyFrameTimes[i];
}
SubstanceTweenAnimationUtility.CacheAnimatedProceduralVariables(substanceMaterialParams, animationParams);
}
public static void InsertKeyframe(int index, SubstanceMaterialParams substanceMaterialParams, SubstanceAnimationParams animationParams, SubstanceToolParams substanceToolParams)
{
if (animationParams.keyFrameTimes.Count > 0)
{
for (int i = 0; i <= animationParams.keyFrameTimes.Count - 1; i++)
{ // Goes through each key frame and checks if the keyframe that you are trying to create has the same number of parameters as the rest and if they all save Output parameters or not.
if (substanceMaterialParams.saveOutputParameters && substanceMaterialParams.MaterialVariableKeyframeList[i].hasParametersWithoutRange == false)
{ //Substance designer can export special properties like '$randomSeed' that can be saved. this checks if you selected to save those objects and turned it off later
UnityEditor.EditorUtility.DisplayDialog("Error", "Could not save keyframe because you are saving Parameters without a range however keyframe " + (i + 1) + " does " +
"not save these variables. To fix this uncheck \"Save Output Parameters\" on this frame and try again or check \"Save Output Parameters\" then select and overWrite on every other frame. ", "OK");
return;
}
if (!substanceMaterialParams.saveOutputParameters && substanceMaterialParams.MaterialVariableKeyframeList[i].hasParametersWithoutRange == true)
{
UnityEditor.EditorUtility.DisplayDialog("Error", "Could not save keyframe because you are not saving Parameters without a range however keyframe " + i + " does " +
"save these variables. To fix this check \"Save Output Parameters\" on this frame and try again or uncheck \"Save Output Parameters\" then select and overWrite on every other frame. ", "OK");
return;
}
}
substanceMaterialParams.MaterialVariableKeyframeList.Insert(index, new MaterialVariableListHolder());
substanceToolParams.DebugStrings.Add("Created KeyFrame: " + substanceMaterialParams.MaterialVariableKeyframeList.Count);
substanceMaterialParams.MaterialVariableKeyframeDictionaryList.Insert(index, new MaterialVariableDictionaryHolder());
SubstanceTweenStorageUtility.AddProceduralVariablesToList(substanceMaterialParams.MaterialVariableKeyframeList[index], substanceMaterialParams, animationParams, substanceToolParams);
SubstanceTweenStorageUtility.AddProceduralVariablesToDictionary(substanceMaterialParams.MaterialVariableKeyframeDictionaryList[index], substanceMaterialParams, animationParams, substanceToolParams);
animationParams.keyframeSum = 0;
for (int i = 0; i < index; i++)
{
animationParams.keyframeSum += substanceMaterialParams.MaterialVariableKeyframeList[i].animationTime;
}
if (index >= 1)
{
substanceMaterialParams.MaterialVariableKeyframeList[index - 1].animationTime = animationParams.currentAnimationTime;
animationParams.keyFrameTimes[index - 1] = animationParams.currentAnimationTime;
}
else
{
substanceMaterialParams.MaterialVariableKeyframeList[index - 1].animationTime = animationParams.currentAnimationTime;
animationParams.keyFrameTimes[index - 1] = animationParams.currentAnimationTime;
}
substanceMaterialParams.MaterialVariableKeyframeList[index].animationTime = animationParams.keyframeSum - animationParams.animationTimeRestartEnd;
animationParams.keyFrameTimes.Insert(index, animationParams.substanceCurve.keys[index + 1].time - animationParams.substanceCurve.keys[index].time); // note: change animation time if inserting keyframe
animationParams.keyFrames++;
}
animationParams.substanceCurveBackup.keys = animationParams.substanceCurve.keys;
SubstanceTweenAnimationUtility.CacheAnimatedProceduralVariables(substanceMaterialParams, animationParams);
SubstanceTweenAnimationUtility.CalculateAnimationLength(substanceMaterialParams, animationParams);
}
public static void ReadJSON(SubstanceMaterialParams substanceMaterialParams, SubstanceAnimationParams animationParams, SubstanceToolParams substanceToolParams)
{
string path = EditorUtility.OpenFilePanel("", "", "json"); // 'Open' Dialog that only accepts JSON files
if (path.Length != 0)
{
string dataAsJson = File.ReadAllText(path);
var stream = new FileStream(path, FileMode.Open);
if (stream.Length != 0)
{
MaterialVariableListHolder jsonContainer = JsonUtility.FromJson <MaterialVariableListHolder>(dataAsJson);
SubstanceTweenSetParameterUtility.SetProceduralVariablesFromList(jsonContainer, substanceMaterialParams, animationParams, substanceToolParams);
substanceMaterialParams.MainTexOffset = jsonContainer.MainTex;
Color jsonEmissionColor = new Color(0, 0, 0, 0);
jsonEmissionColor = jsonContainer.emissionColor;
if (substanceMaterialParams.rend.sharedMaterial.HasProperty("_EmissionColor"))
{
substanceMaterialParams.emissionInput = jsonEmissionColor;
substanceMaterialParams.rend.sharedMaterial.SetColor("_EmissionColor", jsonEmissionColor);
substanceToolParams.selectedPrefabScript.emissionInput = substanceMaterialParams.emissionInput;
}
stream.Close();
substanceToolParams.DebugStrings.Add("-----------------------------------");
substanceToolParams.DebugStrings.Add("Read XML file " + " from: " + stream.Name + ", File has: ");
if (jsonContainer.PropertyMaterialName != null)
{
substanceToolParams.DebugStrings.Add("Material Name: " + jsonContainer.PropertyMaterialName);
}
substanceToolParams.DebugStrings.Add(jsonContainer.PropertyName.Count + " Total Properties");
substanceToolParams.DebugStrings.Add(jsonContainer.PropertyFloat.Count + " Float Properties");
substanceToolParams.DebugStrings.Add(jsonContainer.PropertyColor.Count + " Color Properties ");
substanceToolParams.DebugStrings.Add(jsonContainer.PropertyVector4.Count + " Vector4 Properties");
substanceToolParams.DebugStrings.Add(jsonContainer.PropertyVector3.Count + " Vector3 Properties");
substanceToolParams.DebugStrings.Add(jsonContainer.PropertyVector2.Count + " Vector2 Properties");
substanceToolParams.DebugStrings.Add(jsonContainer.PropertyEnum.Count + " Enum Properties");
substanceToolParams.DebugStrings.Add(jsonContainer.PropertyBool.Count + " Boolean Properties");
substanceToolParams.DebugStrings.Add(jsonContainer.myKeys.Count + " Keys");
substanceToolParams.DebugStrings.Add(jsonContainer.myValues.Count + " Values");
substanceToolParams.DebugStrings.Add("_EmissionColor = " + jsonContainer.emissionColor);
substanceToolParams.DebugStrings.Add("_MainTex = " + substanceMaterialParams.MainTexOffset);
substanceToolParams.DebugStrings.Add("-----------------------------------");
substanceMaterialParams.substance.RebuildTexturesImmediately();
}
}
substanceToolParams.lastAction = MethodBase.GetCurrentMethod().Name.ToString();
SubstanceTweenAnimationUtility.CacheAnimatedProceduralVariables(substanceMaterialParams, animationParams);
} // Sets current material variables from a JSON file without creating a keyframe
public static void ReadXML(SubstanceMaterialParams substanceMaterialParams, SubstanceAnimationParams animationParams, SubstanceToolParams substanceToolParams) // Sets current material variables from a XML file without creating a keyframe.
{
var serializer = new XmlSerializer(typeof(MaterialVariableListHolder));
string path = EditorUtility.OpenFilePanel("", "", "xml"); // 'Open' Dialog that only accepts XML files
if (path.Length != 0)
{
var stream = new FileStream(path, FileMode.Open);
if (stream.Length != 0)
{
var container = serializer.Deserialize(stream) as MaterialVariableListHolder; //Convert XML to a list
SubstanceTweenSetParameterUtility.SetProceduralVariablesFromList(container, substanceMaterialParams, animationParams, substanceToolParams);
substanceMaterialParams.MainTexOffset = container.MainTex;
Color xmlEmissionColor = new Color(0, 0, 0, 0);
xmlEmissionColor = container.emissionColor;
if (substanceMaterialParams.rend.sharedMaterial.HasProperty("_EmissionColor"))
{
substanceMaterialParams.emissionInput = xmlEmissionColor;
substanceMaterialParams.rend.sharedMaterial.SetColor("_EmissionColor", xmlEmissionColor);
}
stream.Close();
substanceToolParams.DebugStrings.Add("-----------------------------------");
substanceToolParams.DebugStrings.Add("Read XML file " + " from: " + stream.Name + ", File has: ");
if (container.PropertyMaterialName != null)
{
substanceToolParams.DebugStrings.Add("Material Name: " + container.PropertyMaterialName);
}
substanceToolParams.DebugStrings.Add(container.PropertyName.Count + " Total Properties");
substanceToolParams.DebugStrings.Add(container.PropertyFloat.Count + " Float Properties");
substanceToolParams.DebugStrings.Add(container.PropertyColor.Count + " Color Properties ");
substanceToolParams.DebugStrings.Add(container.PropertyVector4.Count + " Vector4 Properties");
substanceToolParams.DebugStrings.Add(container.PropertyVector3.Count + " Vector3 Properties");
substanceToolParams.DebugStrings.Add(container.PropertyVector2.Count + " Vector2 Properties");
substanceToolParams.DebugStrings.Add(container.PropertyEnum.Count + " Enum Properties");
substanceToolParams.DebugStrings.Add(container.PropertyBool.Count + " Boolean Properties");
substanceToolParams.DebugStrings.Add(container.myKeys.Count + " Keys");
substanceToolParams.DebugStrings.Add(container.myValues.Count + " Values");
substanceToolParams.DebugStrings.Add("_EmissionColor = " + container.emissionColor);
substanceToolParams.DebugStrings.Add("_MainTex = " + substanceMaterialParams.MainTexOffset);
substanceToolParams.DebugStrings.Add("-----------------------------------");
substanceMaterialParams.substance.RebuildTexturesImmediately();
}
}
substanceToolParams.lastAction = MethodBase.GetCurrentMethod().Name.ToString();
SubstanceTweenAnimationUtility.CacheAnimatedProceduralVariables(substanceMaterialParams, animationParams);
}
public static void OverWriteKeyframe(int index, SubstanceMaterialParams substanceMaterialParams, SubstanceAnimationParams animationParams, SubstanceToolParams substanceToolParams)// Overwrites a keyframe with the current procedural values
{
if (animationParams.keyFrameTimes.Count >= 1)
{
if (index >= 0)
{
substanceMaterialParams.MaterialVariableKeyframeList.Remove(substanceMaterialParams.MaterialVariableKeyframeList[index]);
substanceMaterialParams.MaterialVariableKeyframeList.Insert(index, new MaterialVariableListHolder());
SubstanceTweenStorageUtility.AddProceduralVariablesToList(substanceMaterialParams.MaterialVariableKeyframeList[index], substanceMaterialParams, animationParams, substanceToolParams);
substanceMaterialParams.MaterialVariableKeyframeDictionaryList.Remove(substanceMaterialParams.MaterialVariableKeyframeDictionaryList[index]);
substanceMaterialParams.MaterialVariableKeyframeDictionaryList.Insert(index, new MaterialVariableDictionaryHolder());
SubstanceTweenStorageUtility.AddProceduralVariablesToDictionary(substanceMaterialParams.MaterialVariableKeyframeDictionaryList[index], substanceMaterialParams, animationParams, substanceToolParams);
substanceToolParams.DebugStrings.Add("OverWrote Keyframe: " + (index + 1));
}
}
animationParams.substanceCurveBackup.keys = animationParams.substanceCurve.keys;
SubstanceTweenAnimationUtility.CacheAnimatedProceduralVariables(substanceMaterialParams, animationParams);
}
public static void ToggleAnimation(List <MaterialVariableDictionaryHolder> keyframeDictList, SubstanceMaterialParams substanceMaterialParams, SubstanceAnimationParams animationParams, SubstanceToolParams substanceToolParams) //Pause-Play animation
{
if (keyframeDictList.Count >= 2 && keyframeDictList[0].PropertyMaterialName == substanceMaterialParams.substance.name) // if you have 2 transitions and the name of the selected substance matches the name on keyframe 1
{
if (animationParams.substanceLerp) // pause the animation, Set all values not to cache and clear the list of animated variables, it will be rebuilt when playing the animation
{
substanceMaterialParams.MainTexOffset = substanceMaterialParams.MaterialVariableKeyframeDictionaryList[animationParams.currentKeyframeIndex].MainTex;
animationParams.substanceLerp = false;
}
else if (!animationParams.substanceLerp)//Play animation, find any variables that change(animated) and set them to cache then add them to a list.
{
SubstanceTweenAnimationUtility.CacheAnimatedProceduralVariables(substanceMaterialParams, animationParams);
animationParams.substanceLerp = true;
}
}
else if (keyframeDictList.Count >= 2)
{ // If material names are different
substanceToolParams.DebugStrings.Add("Tried to animate object: " + substanceToolParams.currentSelection + " but the Transition Material name " + keyframeDictList[0].PropertyMaterialName + " did not match the current Procedural Material name: " + substanceMaterialParams.substance.name);
var renameMaterialOption = UnityEditor.EditorUtility.DisplayDialog(
"error",
"Transition Material name " + keyframeDictList[0].PropertyMaterialName + " does not match current Procedural Material name: " + substanceMaterialParams.substance.name + ". Would you like to rename " + keyframeDictList[0].PropertyMaterialName + " to " + substanceMaterialParams.substance.name + "?"
+ " (Only do this if you are sure the materials are the same and only have different names)", "Yes", "No");
if (renameMaterialOption)
{
substanceToolParams.DebugStrings.Add("Renamed Material: " + keyframeDictList[0].PropertyMaterialName + " To: " + substanceMaterialParams.substance.name);
keyframeDictList[0].PropertyMaterialName = substanceMaterialParams.substance.name; // Saves Substance name in keyframe as current substance name
for (int i = 0; i <= keyframeDictList.Count - 1; i++)
{
keyframeDictList[i].PropertyMaterialName = substanceMaterialParams.substance.name;
}
animationParams.substanceLerp = true;
}
else
{
substanceToolParams.DebugStrings.Add("Did not rename or take any other action.");
}
}
else
{
UnityEditor.EditorUtility.DisplayDialog("error", "You do not have two keyframes", "OK");
}
}
public static void CheckForAddKeyFromCurveEditor(SubstanceMaterialParams substanceMaterialParams, SubstanceAnimationParams animationParams, SubstanceToolParams substanceToolParams, SubstanceFlickerParams flickerValues)
{
for (int i = 0; i <= animationParams.substanceCurveBackup.keys.Count() - 1; i++)
{
if (i <= animationParams.substanceCurve.keys.Count() - 1 && animationParams.substanceCurve.keys[i].time != animationParams.substanceCurveBackup.keys[i].time) // find keyframe that has just been created or deleted in the curve editor
{
if (animationParams.substanceCurve.keys.Count() > animationParams.substanceCurveBackup.keys.Count())
{
animationParams.substanceCurve.MoveKey(i, new Keyframe(animationParams.substanceCurve.keys[i].time, animationParams.substanceCurve.keys[i].time)); // lerp does not work correctly if the keyframe value is different than the time. i cant edit the key so i delete then add a new one
float tempKeyframeTime = animationParams.substanceCurve.keys[i].time;
SubstanceTweenSetParameterUtility.SetProceduralMaterialBasedOnAnimationTime(ref tempKeyframeTime, substanceMaterialParams, animationParams, substanceToolParams, flickerValues);
SubstanceTweenKeyframeUtility.InsertKeyframe(i, substanceMaterialParams, animationParams, substanceToolParams);
SubstanceTweenKeyframeUtility.SelectKeyframe(i, substanceMaterialParams, animationParams, substanceToolParams);
animationParams.currentAnimationTime = 0;
animationParams.substanceCurveBackup.keys = animationParams.substanceCurve.keys;
SubstanceTweenAnimationUtility.CalculateAnimationLength(substanceMaterialParams, animationParams);
return;
}
}
}
}
public static void CheckForRemoveOrEditFromCurveEditor(SubstanceMaterialParams substanceMaterialParams, SubstanceAnimationParams animationParams, SubstanceToolParams substanceToolParams, SubstanceFlickerParams flickerValues)
{
bool inEditKeysMode = false;
int keyframesModifiedSoFar = 0; //number of keyframes deleted edited so far
int curvePointsCountDifference = animationParams.substanceCurveBackup.keys.Count() - animationParams.substanceCurve.keys.Count(); // difference between number of points before the change compared to the number of points after the change
List <float> BackupKeyframePointTimes = new List <float>(); // points on curve before change
List <float> CurrentKeyframePointTimes = new List <float>(); // points on curve after change
Keyframe firstEditedKeyframeBeforeEdit = new Keyframe(-1, -1); //the first keyframe in the list that has been edited ore deleted
int firstEditedKeyframeIndexBeforeEdit = -1; // index of the first edited keyframe
if (animationParams.substanceCurve.keys[0].time != 0)
{
animationParams.substanceCurve.keys[0].time = 0;
}
for (int i = 0; i <= animationParams.substanceCurveBackup.keys.Count() - 1; i++)
{
BackupKeyframePointTimes.Add(animationParams.substanceCurveBackup.keys[i].time);
}
for (int i = 0; i <= animationParams.substanceCurve.keys.Count() - 1; i++)
{
CurrentKeyframePointTimes.Add(animationParams.substanceCurve.keys[i].time);
}
for (int i = 0; i <= BackupKeyframePointTimes.Count() - 2; i++)
{
if (!CurrentKeyframePointTimes.Contains(BackupKeyframePointTimes[i]))
{ // find index of the first key that has ben edited using context menu
firstEditedKeyframeBeforeEdit = animationParams.substanceCurveBackup.keys[i];
float tempKeyframeTime = firstEditedKeyframeBeforeEdit.time;
firstEditedKeyframeIndexBeforeEdit = i;
SubstanceTweenSetParameterUtility.SetProceduralMaterialBasedOnAnimationTime(ref tempKeyframeTime, substanceMaterialParams, animationParams, substanceToolParams, flickerValues);
break;
}
}
for (int i = 0; i <= CurrentKeyframePointTimes.Count() - 2; i++)
{
if (!BackupKeyframePointTimes.Contains(CurrentKeyframePointTimes[i]))
{// if i use the context menu to edit multiple keyframes to a value that is not already on the graph i can find that new keyframe here.
// I can tell when i have EDITED a keyframe to a new value because when deleting keyframes, every new point's time should also exist in the backup
inEditKeysMode = true;
float tempKeyframeTime = firstEditedKeyframeBeforeEdit.time;
SubstanceTweenSetParameterUtility.SetProceduralMaterialBasedOnAnimationTime(ref tempKeyframeTime, substanceMaterialParams, animationParams, substanceToolParams, flickerValues); // find/set material based on first edited keyframe
if (firstEditedKeyframeIndexBeforeEdit != -1) // if multiple keyframes has been edited using context menu
{
SubstanceTweenKeyframeUtility.OverWriteKeyframe(firstEditedKeyframeIndexBeforeEdit, substanceMaterialParams, animationParams, substanceToolParams); // overwrite new keyframe with material of the first edited keyframe
}
}
}
for (int i = BackupKeyframePointTimes.Count() - 1; i > 0; i--) // Go through every key in the backup list(Before the keys got deleted)
{
if (!CurrentKeyframePointTimes.Contains(BackupKeyframePointTimes[i])) // if the current list of curve points does not contain this value(it was deleted in the curve editor)
{ //Find the index of the value and delete any information that has not already been deleted in the curve editor
// get the index of the deleted point and delete the Dictionary/List associated with that index
keyframesModifiedSoFar++;
animationParams.keyFrameTimes.RemoveAt(BackupKeyframePointTimes.IndexOf(BackupKeyframePointTimes[i]));
substanceMaterialParams.MaterialVariableKeyframeList.RemoveAt(BackupKeyframePointTimes.IndexOf(BackupKeyframePointTimes[i]));
substanceMaterialParams.MaterialVariableKeyframeDictionaryList.RemoveAt(BackupKeyframePointTimes.IndexOf(BackupKeyframePointTimes[i]));
if (animationParams.keyFrames > 0)
{
animationParams.keyFrames--;
}
}
if (inEditKeysMode && i == 1 && keyframesModifiedSoFar > 0)
{ // if i edited multiple keyframes at the same time using the context menu I insert a keyframe when i reach the end of the for loop
SubstanceTweenKeyframeUtility.InsertKeyframe(i, substanceMaterialParams, animationParams, substanceToolParams);
}
}
for (int i = 0; i <= animationParams.substanceCurve.keys.Count() - 2; i++)
{ // rebuild/refresh animation times
animationParams.keyFrameTimes[i] = animationParams.substanceCurve.keys[i + 1].time - animationParams.substanceCurve.keys[i].time; // this keyframe time = (next keyframe time - This keyframe time)
substanceMaterialParams.MaterialVariableKeyframeList[i].animationTime = animationParams.substanceCurve.keys[i + 1].time - animationParams.substanceCurve.keys[i].time;
}
if (curvePointsCountDifference != keyframesModifiedSoFar)
{ // Because curvePoint EditDifference != keyframes Edited/changed, I know that keyframes have been changed with 'Edit Keys..' and not 'Delete'
// when editing multipule keyframes to a new singular time that is not already on the list,
// there should always be more edited keyframes then the difference between current curve points and backup curve points.
if (animationParams.substanceCurve.keys[animationParams.substanceCurve.keys.Count() - 1].time > animationParams.substanceCurveBackup.keys[animationParams.substanceCurveBackup.keys.Count() - 1].time)
{// Edited multiple keyframes to a new time that is more than the length of the backup curve
SubstanceTweenKeyframeUtility.CreateKeyframe(substanceMaterialParams, animationParams, substanceToolParams);
}
}
animationParams.substanceCurveBackup.keys = animationParams.substanceCurve.keys;
SubstanceTweenAnimationUtility.CalculateAnimationLength(substanceMaterialParams, animationParams);
inEditKeysMode = false;
}
public static void SavePrefab(SubstanceMaterialParams substanceMaterialParams, SubstanceAnimationParams animationParams, SubstanceToolParams substanceToolParams, SubstancePerformanceParams substancePerformanceParams, SubstanceFlickerParams flickerValues) // Saves a Prefab to a specified folder
{
string prefabPath = EditorUtility.SaveFilePanelInProject("", "", "prefab", "");
if (prefabPath.Length != 0)
{
GameObject prefab = PrefabUtility.CreatePrefab(prefabPath, substanceToolParams.currentSelection.gameObject, ReplacePrefabOptions.Default);
if (prefab.GetComponent <PrefabProperties>() != null)
{
UnityEngine.Object.DestroyImmediate(prefab.GetComponent <PrefabProperties>(), true);
}
prefab.AddComponent <PrefabProperties>(); // adds prefab script to prefab
PrefabProperties prefabProperties = prefab.GetComponent <PrefabProperties>();
prefabProperties.substance = substanceMaterialParams.substance;
Renderer prefabRend = prefab.GetComponent <Renderer>();
prefabRend.material = substanceMaterialParams.substance;
if (animationParams.animationType == SubstanceAnimationParams.AnimationType.Loop)
{
prefabProperties.animationType = PrefabProperties.AnimationType.Loop;
}
if (animationParams.animationType == SubstanceAnimationParams.AnimationType.BackAndForth)
{
prefabProperties.animationType = PrefabProperties.AnimationType.BackAndForth;
}
substanceToolParams.DebugStrings.Add("Created prefab: " + prefab.name);
if (prefabRend.sharedMaterial)
{
substanceToolParams.DebugStrings.Add("Prefab material: " + prefabRend.sharedMaterial.name);
}
if (substanceMaterialParams.MaterialVariableKeyframeList.Count >= 1)
{//writes keyfame lists to prefab(Could not serialize dictionaries)
for (int i = 0; i <= substanceMaterialParams.MaterialVariableKeyframeList.Count - 1; i++)
{
if (prefabProperties.keyFrameTimes.Count == 0)
{
prefabProperties.MaterialVariableKeyframeList.Add(new MaterialVariableListHolder());
prefabProperties.MaterialVariableKeyframeList[0] = substanceMaterialParams.MaterialVariableKeyframeList[0];
prefabProperties.MaterialVariableKeyframeList[0].PropertyMaterialName = substanceMaterialParams.substance.name;
prefabProperties.MaterialVariableKeyframeList[0].emissionColor = substanceMaterialParams.MaterialVariableKeyframeList[0].emissionColor;
prefabProperties.MaterialVariableKeyframeList[0].MainTex = substanceMaterialParams.MaterialVariableKeyframeList[prefabProperties.keyFrames].MainTex;
prefabProperties.keyFrameTimes.Add(substanceMaterialParams.MaterialVariableKeyframeList[0].animationTime);
prefabProperties.prefabAnimationCurve = new AnimationCurve();
prefabProperties.prefabAnimationCurve.AddKey(new Keyframe(animationParams.substanceCurve.keys[0].time, animationParams.substanceCurve.keys[0].value, animationParams.substanceCurve.keys[0].inTangent, animationParams.substanceCurve.keys[0].outTangent));
AnimationUtility.SetKeyBroken(prefabProperties.prefabAnimationCurve, 0, true);
if (substanceMaterialParams.MaterialVariableKeyframeList[0].hasParametersWithoutRange)
{
prefabProperties.MaterialVariableKeyframeList[0].hasParametersWithoutRange = true;
}
else
{
prefabProperties.MaterialVariableKeyframeList[0].hasParametersWithoutRange = false;
}
prefabProperties.keyFrames++;
}
else // After one keyframe is created create the rest
{
prefabProperties.MaterialVariableKeyframeList.Add(new MaterialVariableListHolder());
prefabProperties.MaterialVariableKeyframeList[prefabProperties.keyFrames] = substanceMaterialParams.MaterialVariableKeyframeList[prefabProperties.keyFrames];
prefabProperties.MaterialVariableKeyframeList[prefabProperties.keyFrames].PropertyMaterialName = substanceMaterialParams.substance.name;
prefabProperties.MaterialVariableKeyframeList[prefabProperties.keyFrames].emissionColor = substanceMaterialParams.MaterialVariableKeyframeList[prefabProperties.keyFrames].emissionColor;
prefabProperties.MaterialVariableKeyframeList[prefabProperties.keyFrames].MainTex = substanceMaterialParams.MaterialVariableKeyframeList[prefabProperties.keyFrames].MainTex;
prefabProperties.keyFrameTimes.Add(substanceMaterialParams.MaterialVariableKeyframeList[prefabProperties.keyFrames].animationTime);
prefabProperties.prefabAnimationCurve.AddKey(new Keyframe(animationParams.substanceCurve.keys[prefabProperties.keyFrames].time, animationParams.substanceCurve.keys[prefabProperties.keyFrames].value, animationParams.substanceCurve.keys[prefabProperties.keyFrames].inTangent, animationParams.substanceCurve.keys[prefabProperties.keyFrames].outTangent));
if (substanceMaterialParams.saveOutputParameters)
{
prefabProperties.MaterialVariableKeyframeList[prefabProperties.keyFrames].hasParametersWithoutRange = true;
}
else
{
prefabProperties.MaterialVariableKeyframeList[prefabProperties.keyFrames].hasParametersWithoutRange = false;
}
prefabProperties.keyFrames++;
}
}
prefabProperties.keyFrameTimesOriginal = animationParams.keyFrameTimes;
prefabProperties.prefabAnimationCurveBackup = prefabProperties.prefabAnimationCurve;
prefabProperties.MaterialVariableKeyframeDictionaryList = substanceMaterialParams.MaterialVariableKeyframeDictionaryList;
SubstanceTweenAnimationUtility.DeleteNonAnimatingParametersOnPrefab(prefabProperties, substanceMaterialParams, animationParams);
if (substanceMaterialParams.MaterialVariableKeyframeList.Count >= 2)
{
prefabProperties.animateOnStart = true;
prefabProperties.animateBasedOnTime = true;
}
}
if (animationParams.cacheSubstance)
{
prefabProperties.cacheAtStartup = true;
}
else
{
prefabProperties.cacheAtStartup = false;
}
if (animationParams.animateOutputParameters)
{
prefabProperties.animateOutputParameters = true;
}
else
{
prefabProperties.animateOutputParameters = false;
}
if (substancePerformanceParams.myProceduralCacheSize.ToString() == ProceduralCacheSize.Heavy.ToString())
{
prefabProperties.myProceduralCacheSize = PrefabProperties.MyProceduralCacheSize.Heavy;
}
else if (substancePerformanceParams.myProceduralCacheSize.ToString() == ProceduralCacheSize.Medium.ToString())
{
prefabProperties.myProceduralCacheSize = PrefabProperties.MyProceduralCacheSize.Medium;
}
else if (substancePerformanceParams.myProceduralCacheSize.ToString() == ProceduralCacheSize.NoLimit.ToString())
{
prefabProperties.myProceduralCacheSize = PrefabProperties.MyProceduralCacheSize.NoLimit;
}
else if (substancePerformanceParams.myProceduralCacheSize.ToString() == ProceduralCacheSize.None.ToString())
{
prefabProperties.myProceduralCacheSize = PrefabProperties.MyProceduralCacheSize.None;
}
else if (substancePerformanceParams.myProceduralCacheSize.ToString() == ProceduralCacheSize.Tiny.ToString())
{
prefabProperties.myProceduralCacheSize = PrefabProperties.MyProceduralCacheSize.Tiny;
}
if (substancePerformanceParams.mySubstanceProcessorUsage.ToString() == ProceduralProcessorUsage.All.ToString())
{
prefabProperties.mySubstanceProcessorUsage = PrefabProperties.MySubstanceProcessorUsage.All;
}
else if (substancePerformanceParams.mySubstanceProcessorUsage.ToString() == ProceduralProcessorUsage.Half.ToString())
{
prefabProperties.mySubstanceProcessorUsage = PrefabProperties.MySubstanceProcessorUsage.Half;
}
else if (substancePerformanceParams.mySubstanceProcessorUsage.ToString() == ProceduralProcessorUsage.One.ToString())
{
prefabProperties.mySubstanceProcessorUsage = PrefabProperties.MySubstanceProcessorUsage.One;
}
else if (substancePerformanceParams.mySubstanceProcessorUsage.ToString() == ProceduralProcessorUsage.Unsupported.ToString())
{
prefabProperties.mySubstanceProcessorUsage = PrefabProperties.MySubstanceProcessorUsage.Unsupported;
}
if (flickerValues.flickerEnabled)
{
prefabProperties.flickerEnabled = true;
if (flickerValues.flickerFloatToggle)
{
prefabProperties.flickerFloatToggle = true;
}
if (flickerValues.flickerColor3Toggle)
{
prefabProperties.flickerColor3Toggle = true;
}
if (flickerValues.flickerColor4Toggle)
{
prefabProperties.flickerColor4Toggle = true;
}
if (flickerValues.flickerVector2Toggle)
{
prefabProperties.flickerVector2Toggle = true;
}
if (flickerValues.flickerVector3Toggle)
{
prefabProperties.flickerVector3Toggle = true;
}
if (flickerValues.flickerVector4Toggle)
{
prefabProperties.flickerVector4Toggle = true;
}
if (flickerValues.flickerEmissionToggle)
{
prefabProperties.flickerEmissionToggle = true;
}
prefabProperties.flickerMin = flickerValues.flickerMin;
prefabProperties.flickerMax = flickerValues.flickerMax;
}
#if UNITY_2017_1_OR_NEWER
prefabRend.sharedMaterial.enableInstancing = true;// enables GPU instancing
#endif
prefabProperties.useSharedMaterial = true;
prefabProperties.rend = prefabRend;
substanceToolParams.DebugStrings.Add("Prefab Path: " + prefabPath);
substanceToolParams.DebugStrings.Add(prefab.name + " has " + prefabProperties.MaterialVariableKeyframeList.Count + " keyframes");
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
substanceToolParams.lastAction = MethodBase.GetCurrentMethod().Name.ToString();
}
else
{
Debug.LogWarning("No Path/FileName specified for Prefab");
}
}
} //Writes all keyframes to JSON files
public static void ReadAllJSON(SubstanceMaterialParams substanceMaterialParams, SubstanceAnimationParams animationParams, SubstanceToolParams substanceToolParams) // Read JSON files and create keyframes from them.
{
string JsonReadFolderPath = EditorUtility.OpenFolderPanel("Load JSON files from folder", "", ""); //Creates 'Open Folder' Dialog
if (JsonReadFolderPath.Length != 0)
{
string[] JsonReadFiles = Directory.GetFiles(JsonReadFolderPath);//array of selected xml file paths
if (JsonReadFiles.Count() > 0)
{
animationParams.keyFrames = animationParams.keyFrameTimes.Count();
foreach (string jsonReadFile in JsonReadFiles) //for each xml file path in the list.
{
if (jsonReadFile.EndsWith(".json"))
{
string dataAsJson = File.ReadAllText(jsonReadFile);
var stream = new FileStream(jsonReadFile, FileMode.Open); // defines how to use the file at the selected path
MaterialVariableListHolder jsonContainer = JsonUtility.FromJson <MaterialVariableListHolder>(dataAsJson);
SubstanceTweenSetParameterUtility.SetProceduralVariablesFromList(jsonContainer, substanceMaterialParams, animationParams, substanceToolParams); //Sets current substance values from list
substanceMaterialParams.MainTexOffset = jsonContainer.MainTex;
Color jsonEmissionColor = new Color(0, 0, 0, 0);
jsonEmissionColor = jsonContainer.emissionColor;
if (substanceMaterialParams.rend.sharedMaterial.HasProperty("_EmissionColor"))
{
substanceMaterialParams.emissionInput = jsonEmissionColor;
if (substanceToolParams.selectedPrefabScript)
{
substanceToolParams.selectedPrefabScript.emissionInput = substanceMaterialParams.emissionInput;
}
substanceMaterialParams.rend.sharedMaterial.SetColor("_EmissionColor", jsonEmissionColor);
}
stream.Close(); //Close Xml reader
substanceMaterialParams.substance.RebuildTexturesImmediately();
if (animationParams.keyFrameTimes.Count == 0) // Create keyframe from list containing XML variables
{
if (animationParams.substanceCurve.keys.Count() > 0)
{
animationParams.substanceCurve.RemoveKey(0);
animationParams.substanceCurve.AddKey(0, 0);
}
substanceMaterialParams.MaterialVariableKeyframeDictionaryList.Add(new MaterialVariableDictionaryHolder());
substanceMaterialParams.MaterialVariableKeyframeList.Add(new MaterialVariableListHolder());
substanceMaterialParams.MaterialVariableKeyframeList[0] = jsonContainer;
animationParams.keyFrames++;
animationParams.keyFrameTimes.Add(substanceMaterialParams.MaterialVariableKeyframeList[0].animationTime);
AnimationUtility.SetKeyBroken(animationParams.substanceCurve, 0, true);
AnimationUtility.SetKeyLeftTangentMode(animationParams.substanceCurve, 0, AnimationUtility.TangentMode.Linear);
AnimationUtility.SetKeyRightTangentMode(animationParams.substanceCurve, 0, AnimationUtility.TangentMode.Linear);
}
else if (animationParams.keyFrameTimes.Count > 0)
{
substanceMaterialParams.MaterialVariableKeyframeList.Add(new MaterialVariableListHolder());
substanceMaterialParams.MaterialVariableKeyframeList[animationParams.keyFrames] = jsonContainer;
substanceMaterialParams.MaterialVariableKeyframeDictionaryList.Add(new MaterialVariableDictionaryHolder());
substanceMaterialParams.MaterialVariableKeyframeDictionaryList[animationParams.keyFrames] = new MaterialVariableDictionaryHolder();
animationParams.keyFrameTimes.Add(jsonContainer.animationTime);
animationParams.keyframeSum = 0;
for (int i = 0; i < substanceMaterialParams.MaterialVariableKeyframeList.Count() - 1; i++) // -1 to count here 6/10/17
{
animationParams.keyframeSum += substanceMaterialParams.MaterialVariableKeyframeList[i].animationTime;
}
if (jsonContainer.AnimationCurveKeyframeList.Count() >= 1)
{
animationParams.substanceCurve.AddKey(new Keyframe(animationParams.keyframeSum, animationParams.keyframeSum, jsonContainer.AnimationCurveKeyframeList[0].inTangent, jsonContainer.AnimationCurveKeyframeList[0].outTangent));
}
else
{
animationParams.substanceCurve.AddKey(new Keyframe(animationParams.keyframeSum, animationParams.keyframeSum));
}
if (animationParams.keyFrames >= 1)
{
AnimationUtility.SetKeyBroken(animationParams.substanceCurve, animationParams.keyFrames, true);
}
animationParams.keyFrames++;
}
}
substanceToolParams.DebugStrings.Add("Read keyframe from: " + jsonReadFile);
}
substanceToolParams.DebugStrings.Add(animationParams.keyFrames - 1 + " Keyframes created from XML files ");
animationParams.substanceCurveBackup.keys = animationParams.substanceCurve.keys;
substanceToolParams.lastAction = MethodBase.GetCurrentMethod().Name.ToString();
}
else
{
EditorUtility.DisplayDialog("Empty Folder", "No Files were found in the selected folder", "Ok");
}
SubstanceTweenAnimationUtility.CacheAnimatedProceduralVariables(substanceMaterialParams, animationParams);
SubstanceTweenAnimationUtility.CalculateAnimationLength(substanceMaterialParams, animationParams);
}
}
