|
|
using UnityEngine; |
|
|
using UnityEditor; |
|
|
using System.Collections.Generic; |
|
|
|
|
|
// Cartoon FX Easy Editor |
|
|
// (c) 2013-2020 - Jean Moreno |
|
|
|
|
|
public class CFXEasyEditor : EditorWindow |
|
|
{ |
|
|
static private CFXEasyEditor SingleWindow; |
|
|
|
|
|
[MenuItem("Tools/Cartoon FX Easy Editor")] |
|
|
static void ShowWindow() |
|
|
{ |
|
|
CFXEasyEditor window = EditorWindow.GetWindow<CFXEasyEditor>(EditorPrefs.GetBool("CFX_ShowAsToolbox", true), "Easy Editor", true); |
|
|
window.minSize = new Vector2(300, 8); |
|
|
window.maxSize = new Vector2(300, 8); |
|
|
} |
|
|
|
|
|
private int SelectedParticleSystemsCount; |
|
|
|
|
|
//Change Start Color |
|
|
private bool AffectAlpha = true; |
|
|
private Color ColorValue = Color.white; |
|
|
private Color ColorValue2 = Color.white; |
|
|
|
|
|
//Scale |
|
|
private float ScalingValue = 2.0f; |
|
|
private float LTScalingValue = 1.0f; |
|
|
|
|
|
//Delay |
|
|
private float DelayValue = 1.0f; |
|
|
|
|
|
//Duration |
|
|
private float DurationValue = 5.0f; |
|
|
|
|
|
//Tint |
|
|
private bool TintStartColor = true; |
|
|
private bool TintColorModule = true; |
|
|
private bool TintColorSpeedModule = true; |
|
|
private bool TintTrailsModule = true; |
|
|
private bool TintCustomData1 = true; |
|
|
private bool TintCustomData2 = true; |
|
|
private bool TintLights = true; |
|
|
private Color TintColorValue = Color.white; |
|
|
private float TintHueShiftValue = 0f; |
|
|
private float SatShiftValue = 0f; |
|
|
private float ValShiftValue = 0f; |
|
|
|
|
|
//Change Lightness |
|
|
private int LightnessStep = 10; |
|
|
|
|
|
//Module copying system |
|
|
private ParticleSystem copyModulesSourceParticleSystem; |
|
|
|
|
|
private class ParticleSystemModule |
|
|
{ |
|
|
public string name; |
|
|
//public bool selected; |
|
|
//public bool enabledInSource; |
|
|
public string serializedPropertyPath; |
|
|
|
|
|
public ParticleSystemModule(string name, string serializedPropertyPath) |
|
|
{ |
|
|
this.name = " " + name + " "; |
|
|
this.serializedPropertyPath = serializedPropertyPath; |
|
|
} |
|
|
|
|
|
public bool CheckIfEnabledInSource(SerializedObject serializedSource) |
|
|
{ |
|
|
bool enabled = true; |
|
|
var sp = serializedSource.FindProperty(this.serializedPropertyPath); |
|
|
if(sp != null) |
|
|
{ |
|
|
var enabledSp = sp.FindPropertyRelative("enabled"); |
|
|
if(enabledSp != null) |
|
|
{ |
|
|
enabled = enabledSp.boolValue; |
|
|
} |
|
|
} |
|
|
return enabled; |
|
|
} |
|
|
} |
|
|
|
|
|
private ParticleSystemModule[] modulesToCopy = null; |
|
|
private List<string> initialModuleExtraProperties = null; |
|
|
private GUIContent[] modulesLabels = null; |
|
|
|
|
|
private ParticleSystem selectedParticleSystem; |
|
|
private bool[] selectedModules; |
|
|
private bool[] enabledModules; |
|
|
/* |
|
|
private bool[] selectedModulesMutate; |
|
|
private bool[] enabledModulesMutate; |
|
|
|
|
|
private float mutatePercentage = 0.1f; |
|
|
*/ |
|
|
|
|
|
//Foldouts |
|
|
bool basicFoldout = false; |
|
|
bool colorFoldout = false; |
|
|
bool copyFoldout = false; |
|
|
//bool mutateFoldout = false; |
|
|
|
|
|
//Editor Prefs |
|
|
private bool pref_ShowAsToolbox; |
|
|
private bool pref_IncludeChildren; |
|
|
private bool pref_HideDisabledModulesCopy; |
|
|
|
|
|
void OnEnable() |
|
|
{ |
|
|
//Load Settings |
|
|
pref_ShowAsToolbox = EditorPrefs.GetBool("CFX_ShowAsToolbox", true); |
|
|
pref_IncludeChildren = EditorPrefs.GetBool("CFX_IncludeChildren", true); |
|
|
pref_HideDisabledModulesCopy = EditorPrefs.GetBool("CFX_HideDisabledModulesCopy", true); |
|
|
basicFoldout = EditorPrefs.GetBool("CFX_BasicFoldout", false); |
|
|
colorFoldout = EditorPrefs.GetBool("CFX_ColorFoldout", false); |
|
|
copyFoldout = EditorPrefs.GetBool("CFX_CopyFoldout", false); |
|
|
//mutateFoldout = EditorPrefs.GetBool("CFX_MutateFoldout", false); |
|
|
|
|
|
ParticleSystem ps = null; |
|
|
if (Selection.activeGameObject != null) |
|
|
{ |
|
|
ps = Selection.activeGameObject.GetComponent<ParticleSystem>(); |
|
|
} |
|
|
if (ps == null && copyModulesSourceParticleSystem != null) |
|
|
{ |
|
|
ps = copyModulesSourceParticleSystem.GetComponent<ParticleSystem>(); |
|
|
} |
|
|
FetchParticleSystemModules(ps); |
|
|
//RefreshCurrentlyEnabledModules(ps, ref enabledModulesMutate); |
|
|
|
|
|
OnSelectionChange(); |
|
|
} |
|
|
|
|
|
void OnSelectionChange() |
|
|
{ |
|
|
UpdateSelectionCount(); |
|
|
this.Repaint(); |
|
|
|
|
|
if (Selection.activeGameObject != null) |
|
|
{ |
|
|
selectedParticleSystem = Selection.activeGameObject.GetComponent<ParticleSystem>(); |
|
|
FetchParticleSystemModules(selectedParticleSystem); |
|
|
} |
|
|
} |
|
|
|
|
|
void FetchParticleSystemModules(ParticleSystem ps) |
|
|
{ |
|
|
// Fetch the modules list from a Particle System |
|
|
if (modulesToCopy == null && ps != null) |
|
|
{ |
|
|
initialModuleExtraProperties = new List<string>(); |
|
|
var modulesList = new List<ParticleSystemModule>(); |
|
|
var modulesLabelsList = new List<GUIContent>(); |
|
|
var so = new SerializedObject(ps); |
|
|
var sp = so.GetIterator(); |
|
|
sp.Next(true); |
|
|
while (sp.NextVisible(false)) |
|
|
{ |
|
|
if (sp.propertyPath.EndsWith("Module")) |
|
|
{ |
|
|
var module = new ParticleSystemModule(sp.propertyPath.Replace("Module", ""), sp.propertyPath); |
|
|
modulesList.Add(module); |
|
|
modulesLabelsList.Add(new GUIContent(sp.propertyPath.Replace("Module", ""))); |
|
|
} |
|
|
else |
|
|
{ |
|
|
initialModuleExtraProperties.Add(sp.propertyPath); |
|
|
} |
|
|
} |
|
|
modulesToCopy = modulesList.ToArray(); |
|
|
|
|
|
// add one entry for renderer (not a module but a component) |
|
|
modulesLabelsList.Add(new GUIContent("Renderer")); |
|
|
modulesLabels = modulesLabelsList.ToArray(); |
|
|
} |
|
|
} |
|
|
|
|
|
void OnDisable() |
|
|
{ |
|
|
//Save Settings |
|
|
EditorPrefs.SetBool("CFX_BasicFoldout", basicFoldout); |
|
|
EditorPrefs.SetBool("CFX_ColorFoldout", colorFoldout); |
|
|
EditorPrefs.SetBool("CFX_CopyFoldout", copyFoldout); |
|
|
//EditorPrefs.SetBool("CFX_MutateFoldout", mutateFoldout); |
|
|
} |
|
|
|
|
|
void UpdateSelectionCount() |
|
|
{ |
|
|
SelectedParticleSystemsCount = 0; |
|
|
foreach(var go in Selection.gameObjects) |
|
|
{ |
|
|
ParticleSystem[] systems; |
|
|
if(pref_IncludeChildren) |
|
|
systems = go.GetComponentsInChildren<ParticleSystem>(true); |
|
|
else |
|
|
systems = go.GetComponents<ParticleSystem>(); |
|
|
|
|
|
SelectedParticleSystemsCount += systems.Length; |
|
|
} |
|
|
} |
|
|
|
|
|
void OnGUI() |
|
|
{ |
|
|
GUILayout.Space(4); |
|
|
|
|
|
GUILayout.BeginHorizontal(); |
|
|
var rect = EditorGUILayout.GetControlRect(false, EditorGUIUtility.singleLineHeight, EditorStyles.label); |
|
|
GUI.Label(rect, "Cartoon FX Easy Editor", EditorStyles.boldLabel); |
|
|
var guiColor = GUI.color; |
|
|
GUI.color *= new Color(.8f,.8f,.8f,1f); |
|
|
pref_ShowAsToolbox = GUILayout.Toggle(pref_ShowAsToolbox, new GUIContent("Toolbox", "If enabled, the window will be displayed as an external toolbox.\nElse it will act as a dockable Unity window."), EditorStyles.miniButton, GUILayout.Width(65)); |
|
|
GUI.color = guiColor; |
|
|
if(GUI.changed) |
|
|
{ |
|
|
EditorPrefs.SetBool("CFX_ShowAsToolbox", pref_ShowAsToolbox); |
|
|
this.Close(); |
|
|
CFXEasyEditor.ShowWindow(); |
|
|
} |
|
|
GUILayout.EndHorizontal(); |
|
|
GUILayout.Label("Easily change properties of any Particle System!", EditorStyles.miniLabel); |
|
|
|
|
|
//---------------------------------------------------------------- |
|
|
|
|
|
pref_IncludeChildren = GUILayout.Toggle(pref_IncludeChildren, new GUIContent("Include Children", "If checked, changes will affect every Particle Systems from each child of the selected GameObject(s)")); |
|
|
if(GUI.changed) |
|
|
{ |
|
|
EditorPrefs.SetBool("CFX_IncludeChildren", pref_IncludeChildren); |
|
|
UpdateSelectionCount(); |
|
|
} |
|
|
|
|
|
GUILayout.Label(string.Format("{0} selected Particle System{1}", SelectedParticleSystemsCount, SelectedParticleSystemsCount > 1 ? "s" : ""), EditorStyles.helpBox); |
|
|
|
|
|
EditorGUILayout.BeginHorizontal(); |
|
|
|
|
|
GUILayout.Label("Test effect(s):"); |
|
|
using(new EditorGUI.DisabledScope(SelectedParticleSystemsCount <= 0)) |
|
|
{ |
|
|
|
|
|
if(GUILayout.Button("Play", EditorStyles.miniButtonLeft, GUILayout.Width(50f))) |
|
|
{ |
|
|
foreach(GameObject go in Selection.gameObjects) |
|
|
{ |
|
|
ParticleSystem[] systems = go.GetComponents<ParticleSystem>(); |
|
|
if(systems.Length == 0) continue; |
|
|
foreach(ParticleSystem system in systems) |
|
|
system.Play(pref_IncludeChildren); |
|
|
} |
|
|
} |
|
|
if(GUILayout.Button("Pause", EditorStyles.miniButtonMid, GUILayout.Width(50f))) |
|
|
{ |
|
|
foreach(GameObject go in Selection.gameObjects) |
|
|
{ |
|
|
ParticleSystem[] systems = go.GetComponents<ParticleSystem>(); |
|
|
if(systems.Length == 0) continue; |
|
|
foreach(ParticleSystem system in systems) |
|
|
system.Pause(pref_IncludeChildren); |
|
|
} |
|
|
} |
|
|
if(GUILayout.Button("Stop", EditorStyles.miniButtonMid, GUILayout.Width(50f))) |
|
|
{ |
|
|
foreach(GameObject go in Selection.gameObjects) |
|
|
{ |
|
|
ParticleSystem[] systems = go.GetComponents<ParticleSystem>(); |
|
|
if(systems.Length == 0) continue; |
|
|
foreach(ParticleSystem system in systems) |
|
|
system.Stop(pref_IncludeChildren); |
|
|
} |
|
|
} |
|
|
if(GUILayout.Button("Clear", EditorStyles.miniButtonRight, GUILayout.Width(50f))) |
|
|
{ |
|
|
foreach(GameObject go in Selection.gameObjects) |
|
|
{ |
|
|
ParticleSystem[] systems = go.GetComponents<ParticleSystem>(); |
|
|
if(systems.Length == 0) continue; |
|
|
foreach(ParticleSystem system in systems) |
|
|
{ |
|
|
system.Stop(pref_IncludeChildren); |
|
|
system.Clear(pref_IncludeChildren); |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
GUILayout.FlexibleSpace(); |
|
|
EditorGUILayout.EndHorizontal(); |
|
|
|
|
|
//---------------------------------------------------------------- |
|
|
|
|
|
//Separator |
|
|
GUISeparator(); |
|
|
//GUILayout.Box("",GUILayout.Width(this.position.width - 12), GUILayout.Height(3)); |
|
|
|
|
|
basicFoldout = EditorGUILayout.Foldout(basicFoldout, "QUICK EDIT", true); |
|
|
if(basicFoldout) |
|
|
{ |
|
|
GUILayout.Space(4); |
|
|
|
|
|
//---------------------------------------------------------------- |
|
|
|
|
|
GUILayout.BeginHorizontal(); |
|
|
if(GUILayout.Button(new GUIContent("Scale Size", "Changes the size of the Particle System(s) and other values accordingly (speed, gravity, etc.)"), GUILayout.Width(120))) |
|
|
{ |
|
|
applyScale(); |
|
|
} |
|
|
GUILayout.Label("Multiplier:",GUILayout.Width(110)); |
|
|
ScalingValue = EditorGUILayout.FloatField(ScalingValue,GUILayout.Width(50)); |
|
|
if(ScalingValue <= 0) ScalingValue = 0.1f; |
|
|
GUILayout.EndHorizontal(); |
|
|
|
|
|
//---------------------------------------------------------------- |
|
|
|
|
|
GUILayout.BeginHorizontal(); |
|
|
if(GUILayout.Button(new GUIContent("Set Speed", "Changes the simulation speed of the Particle System(s)\n1 = default speed"), GUILayout.Width(120))) |
|
|
{ |
|
|
applySpeed(); |
|
|
} |
|
|
GUILayout.Label("Speed:",GUILayout.Width(110)); |
|
|
LTScalingValue = EditorGUILayout.FloatField(LTScalingValue,GUILayout.Width(50)); |
|
|
if(LTScalingValue < 0.0f) LTScalingValue = 0.0f; |
|
|
else if(LTScalingValue > 9999) LTScalingValue = 9999; |
|
|
GUILayout.EndHorizontal(); |
|
|
|
|
|
//---------------------------------------------------------------- |
|
|
|
|
|
GUILayout.BeginHorizontal(); |
|
|
if(GUILayout.Button(new GUIContent("Set Duration", "Changes the duration of the Particle System(s)"), GUILayout.Width(120))) |
|
|
{ |
|
|
applyDuration(); |
|
|
} |
|
|
GUILayout.Label("Duration (sec):",GUILayout.Width(110)); |
|
|
DurationValue = EditorGUILayout.FloatField(DurationValue,GUILayout.Width(50)); |
|
|
if(DurationValue < 0.1f) DurationValue = 0.1f; |
|
|
else if(DurationValue > 9999) DurationValue = 9999; |
|
|
GUILayout.EndHorizontal(); |
|
|
|
|
|
//---------------------------------------------------------------- |
|
|
|
|
|
GUILayout.BeginHorizontal(); |
|
|
if(GUILayout.Button(new GUIContent("Set Delay", "Changes the delay of the Particle System(s)"), GUILayout.Width(120))) |
|
|
{ |
|
|
applyDelay(); |
|
|
} |
|
|
GUILayout.Label("Delay :",GUILayout.Width(110)); |
|
|
DelayValue = EditorGUILayout.FloatField(DelayValue,GUILayout.Width(50)); |
|
|
if(DelayValue < 0.0f) DelayValue = 0.0f; |
|
|
else if(DelayValue > 9999f) DelayValue = 9999f; |
|
|
GUILayout.EndHorizontal(); |
|
|
|
|
|
//---------------------------------------------------------------- |
|
|
|
|
|
GUILayout.Space(2); |
|
|
|
|
|
GUILayout.BeginHorizontal(); |
|
|
if(GUILayout.Button(new GUIContent("Loop", "Loop the effect (might not work properly on some effects such as explosions)"), EditorStyles.miniButtonLeft)) |
|
|
{ |
|
|
loopEffect(true); |
|
|
} |
|
|
if(GUILayout.Button(new GUIContent("Unloop", "Remove looping from the effect"), EditorStyles.miniButtonRight)) |
|
|
{ |
|
|
loopEffect(false); |
|
|
} |
|
|
if(GUILayout.Button(new GUIContent("Prewarm On", "Prewarm the effect (if looped)"), EditorStyles.miniButtonLeft)) |
|
|
{ |
|
|
prewarmEffect(true); |
|
|
} |
|
|
if(GUILayout.Button(new GUIContent("Prewarm Off", "Don't prewarm the effect (if looped)"), EditorStyles.miniButtonRight)) |
|
|
{ |
|
|
prewarmEffect(false); |
|
|
} |
|
|
GUILayout.EndHorizontal(); |
|
|
|
|
|
GUILayout.Space(2); |
|
|
|
|
|
//---------------------------------------------------------------- |
|
|
|
|
|
} |
|
|
|
|
|
//Separator |
|
|
GUISeparator(); |
|
|
//GUILayout.Box("",GUILayout.Width(this.position.width - 12), GUILayout.Height(3)); |
|
|
|
|
|
EditorGUI.BeginChangeCheck(); |
|
|
colorFoldout = EditorGUILayout.Foldout(colorFoldout, "COLOR EDIT", true); |
|
|
if(colorFoldout) |
|
|
{ |
|
|
GUILayout.Space(4); |
|
|
|
|
|
//---------------------------------------------------------------- |
|
|
|
|
|
GUILayout.BeginHorizontal(); |
|
|
if(GUILayout.Button(new GUIContent("Set Start Color(s)", "Changes the color(s) of the Particle System(s)\nSecond Color is used when Start Color is 'Random Between Two Colors'."),GUILayout.Width(120))) |
|
|
{ |
|
|
applyColor(); |
|
|
} |
|
|
ColorValue = EditorGUILayout.ColorField(ColorValue); |
|
|
ColorValue2 = EditorGUILayout.ColorField(ColorValue2); |
|
|
AffectAlpha = GUILayout.Toggle(AffectAlpha, new GUIContent("Alpha", "If checked, the alpha value will also be changed")); |
|
|
GUILayout.EndHorizontal(); |
|
|
|
|
|
//---------------------------------------------------------------- |
|
|
|
|
|
GUILayout.Space(8); |
|
|
|
|
|
using(new EditorGUI.DisabledScope(!TintStartColor && !TintColorModule && !TintColorSpeedModule && !TintTrailsModule && !TintCustomData1 && !TintCustomData2)) |
|
|
{ |
|
|
GUILayout.BeginHorizontal(); |
|
|
if(GUILayout.Button(new GUIContent("Tint Colors", "Colorize the Particle System(s) to a specific color, including gradients!\n(preserving their saturation and value)"), GUILayout.Width(120))) |
|
|
{ |
|
|
tintColor(); |
|
|
} |
|
|
TintColorValue = EditorGUILayout.ColorField(TintColorValue); |
|
|
TintColorValue = HSLColor.FromRGBA(TintColorValue).VividColor(); |
|
|
GUILayout.EndHorizontal(); |
|
|
|
|
|
//---------------------------------------------------------------- |
|
|
|
|
|
GUILayout.BeginHorizontal(); |
|
|
if(GUILayout.Button(new GUIContent("Hue Shift", "Tints the colors of the Particle System(s) by shifting the original hues by a value\n(preserving differences between colors)"), GUILayout.Width(120))) |
|
|
{ |
|
|
hueShift(); |
|
|
} |
|
|
TintHueShiftValue = EditorGUILayout.Slider(TintHueShiftValue, -180f, 180f); |
|
|
GUILayout.EndHorizontal(); |
|
|
|
|
|
//---------------------------------------------------------------- |
|
|
|
|
|
GUILayout.BeginHorizontal(); |
|
|
if(GUILayout.Button(new GUIContent("Saturation Shift", "Change the saturation of the colors of the Particle System(s)\n(preserving their hue and value)"), GUILayout.Width(120))) |
|
|
{ |
|
|
satShift(); |
|
|
} |
|
|
SatShiftValue = EditorGUILayout.Slider(SatShiftValue, -1, 1); |
|
|
GUILayout.EndHorizontal(); |
|
|
|
|
|
//---------------------------------------------------------------- |
|
|
|
|
|
GUILayout.BeginHorizontal(); |
|
|
if(GUILayout.Button(new GUIContent("Value Shift", "Change the value of the colors of the Particle System(s)\n(preserving their hue and saturation)"), GUILayout.Width(120))) |
|
|
{ |
|
|
valShift(); |
|
|
} |
|
|
ValShiftValue = EditorGUILayout.Slider(ValShiftValue, -1, 1); |
|
|
GUILayout.EndHorizontal(); |
|
|
|
|
|
//---------------------------------------------------------------- |
|
|
|
|
|
GUILayout.BeginHorizontal(); |
|
|
if (GUILayout.Button(new GUIContent("Gamma -> Linear", "Converts the colors from Gamma to Linear color space"))) |
|
|
{ |
|
|
gammaToLinear(); |
|
|
} |
|
|
if (GUILayout.Button(new GUIContent("Linear -> Gamma", "Converts the colors from Linear to Gamma color space"))) |
|
|
{ |
|
|
linearToGamma(); |
|
|
} |
|
|
GUILayout.EndHorizontal(); |
|
|
} |
|
|
|
|
|
GUILayout.Space(4); |
|
|
|
|
|
//---------------------------------------------------------------- |
|
|
|
|
|
/* |
|
|
GUILayout.BeginHorizontal(); |
|
|
GUILayout.Label("Add/Substract Lightness:"); |
|
|
|
|
|
LightnessStep = EditorGUILayout.IntField(LightnessStep, GUILayout.Width(30)); |
|
|
if(LightnessStep > 99) LightnessStep = 99; |
|
|
else if(LightnessStep < 1) LightnessStep = 1; |
|
|
GUILayout.Label("%"); |
|
|
|
|
|
if(GUILayout.Button("-", EditorStyles.miniButtonLeft, GUILayout.Width(22))) |
|
|
{ |
|
|
addLightness(true); |
|
|
} |
|
|
if(GUILayout.Button("+", EditorStyles.miniButtonRight, GUILayout.Width(22))) |
|
|
{ |
|
|
addLightness(false); |
|
|
} |
|
|
GUILayout.FlexibleSpace(); |
|
|
GUILayout.EndHorizontal(); |
|
|
*/ |
|
|
|
|
|
//---------------------------------------------------------------- |
|
|
|
|
|
GUILayout.Label("Color Modules to affect:"); |
|
|
|
|
|
GUILayout.BeginHorizontal(); |
|
|
GUILayout.Space(4); |
|
|
TintStartColor = GUILayout.Toggle(TintStartColor, new GUIContent("Start Color", "If checked, the \"Start Color\" value(s) will be affected."), EditorStyles.toolbarButton); |
|
|
TintColorModule = GUILayout.Toggle(TintColorModule, new GUIContent("Color over Lifetime", "If checked, the \"Color over Lifetime\" value(s) will be affected."), EditorStyles.toolbarButton); |
|
|
TintColorSpeedModule = GUILayout.Toggle(TintColorSpeedModule, new GUIContent("Color by Speed", "If checked, the \"Color by Speed\" value(s) will be affected."), EditorStyles.toolbarButton); |
|
|
GUILayout.Space(4); |
|
|
GUILayout.EndHorizontal(); |
|
|
GUILayout.BeginHorizontal(); |
|
|
GUILayout.Space(4); |
|
|
TintTrailsModule = GUILayout.Toggle(TintTrailsModule, new GUIContent("Trails", "If checked, the \"Trails\" value(s) will be affected."), EditorStyles.toolbarButton); |
|
|
TintCustomData1 = GUILayout.Toggle(TintCustomData1, new GUIContent("Custom Data 1", "If checked, the \"Custom Data 1\" value(s) will be affected if they have been set to a color value."), EditorStyles.toolbarButton); |
|
|
TintCustomData2 = GUILayout.Toggle(TintCustomData2, new GUIContent("Custom Data 2", "If checked, the \"Custom Data 2\" value(s) will be affected if they have been set to a color value."), EditorStyles.toolbarButton); |
|
|
GUILayout.Space(4); |
|
|
GUILayout.EndHorizontal(); |
|
|
|
|
|
TintLights = GUILayout.Toggle(TintLights, new GUIContent(" Tint Lights found in the effect's Hierarchy", "Will search for and tint any Lights found in the effect hierarchy.")); |
|
|
|
|
|
GUILayout.Space(4); |
|
|
|
|
|
//---------------------------------------------------------------- |
|
|
|
|
|
} |
|
|
|
|
|
GUISeparator(); |
|
|
|
|
|
//---------------------------------------------------------------- |
|
|
|
|
|
EditorGUI.BeginChangeCheck(); |
|
|
copyFoldout = EditorGUILayout.Foldout(copyFoldout, "COPY MODULES", true); |
|
|
if(copyFoldout) |
|
|
{ |
|
|
GUILayout.Space(4); |
|
|
|
|
|
EditorGUILayout.HelpBox("Copy selected modules from a Particle System to others!", MessageType.Info); |
|
|
|
|
|
GUILayout.Label("Source Particle System to copy from:"); |
|
|
GUILayout.BeginHorizontal(); |
|
|
{ |
|
|
EditorGUI.BeginChangeCheck(); |
|
|
copyModulesSourceParticleSystem = (ParticleSystem)EditorGUILayout.ObjectField(copyModulesSourceParticleSystem, typeof(ParticleSystem), true); |
|
|
if (GUILayout.Button("Get Selected", EditorStyles.miniButton)) |
|
|
{ |
|
|
if (Selection.activeGameObject != null) |
|
|
{ |
|
|
var ps = Selection.activeGameObject.GetComponent<ParticleSystem>(); |
|
|
if (ps != null) |
|
|
{ |
|
|
copyModulesSourceParticleSystem = ps; |
|
|
} |
|
|
} |
|
|
} |
|
|
if (EditorGUI.EndChangeCheck()) |
|
|
{ |
|
|
if (copyModulesSourceParticleSystem != null) |
|
|
{ |
|
|
FetchParticleSystemModules(copyModulesSourceParticleSystem); |
|
|
RefreshCurrentlyEnabledModules(copyModulesSourceParticleSystem, ref enabledModules); |
|
|
} |
|
|
} |
|
|
} |
|
|
GUILayout.EndHorizontal(); |
|
|
|
|
|
EditorGUILayout.LabelField("Modules to Copy:"); |
|
|
|
|
|
GUILayout.Space(4); |
|
|
|
|
|
DrawSelectableModules(ref selectedModules, ref enabledModules, copyModulesSourceParticleSystem); |
|
|
|
|
|
/* |
|
|
|
|
|
GUILayout.BeginHorizontal(); |
|
|
GUILayout.Space(8f); |
|
|
GUISelectModule(modulesToCopy[0]); |
|
|
GUISelectModule(modulesToCopy[1]); |
|
|
GUISelectModule(modulesToCopy[2]); |
|
|
GUILayout.EndHorizontal(); |
|
|
|
|
|
SelectModulesSpace(); |
|
|
GUILayout.BeginHorizontal(); |
|
|
GUILayout.Space(8f); |
|
|
#if UNITY_5_4_OR_NEWER |
|
|
GUISelectModule(modulesToCopy[3]); |
|
|
GUISelectModule(modulesToCopy[4]); |
|
|
GUISelectModule(modulesToCopy[16]); |
|
|
GUISelectModule(modulesToCopy[5]); |
|
|
#else |
|
|
GUISelectModule(modulesToCopy[3]); |
|
|
GUISelectModule(modulesToCopy[4]); |
|
|
GUISelectModule(modulesToCopy[5]); |
|
|
#endif |
|
|
GUILayout.EndHorizontal(); |
|
|
|
|
|
SelectModulesSpace(); |
|
|
GUILayout.BeginHorizontal(); |
|
|
GUILayout.Space(8f); |
|
|
GUISelectModule(modulesToCopy[6]); |
|
|
GUISelectModule(modulesToCopy[7]); |
|
|
GUILayout.EndHorizontal(); |
|
|
|
|
|
SelectModulesSpace(); |
|
|
GUILayout.BeginHorizontal(); |
|
|
GUILayout.Space(8f); |
|
|
GUISelectModule(modulesToCopy[8]); |
|
|
GUISelectModule(modulesToCopy[9]); |
|
|
GUILayout.EndHorizontal(); |
|
|
|
|
|
SelectModulesSpace(); |
|
|
GUILayout.BeginHorizontal(); |
|
|
GUILayout.Space(8f); |
|
|
GUISelectModule(modulesToCopy[10]); |
|
|
GUISelectModule(modulesToCopy[11]); |
|
|
GUILayout.EndHorizontal(); |
|
|
|
|
|
SelectModulesSpace(); |
|
|
GUILayout.BeginHorizontal(); |
|
|
GUILayout.Space(8f); |
|
|
GUISelectModule(modulesToCopy[12]); |
|
|
#if UNITY_5_4_OR_NEWER |
|
|
GUISelectModule(modulesToCopy[17]); |
|
|
#endif |
|
|
GUISelectModule(modulesToCopy[13]); |
|
|
GUILayout.EndHorizontal(); |
|
|
|
|
|
SelectModulesSpace(); |
|
|
GUILayout.BeginHorizontal(); |
|
|
GUILayout.Space(8f); |
|
|
#if UNITY_5_5_OR_NEWER |
|
|
GUISelectModule(modulesToCopy[20]); |
|
|
GUISelectModule(modulesToCopy[19]); |
|
|
GUISelectModule(modulesToCopy[18]); |
|
|
#endif |
|
|
GUISelectModule(modulesToCopy[14]); |
|
|
GUILayout.EndHorizontal(); |
|
|
|
|
|
SelectModulesSpace(); |
|
|
GUILayout.BeginHorizontal(); |
|
|
GUILayout.Space(8f); |
|
|
GUISelectModule(modulesToCopy[15]); |
|
|
GUILayout.EndHorizontal(); |
|
|
|
|
|
GUI.color = guiColor; |
|
|
|
|
|
SelectModulesSpace(); |
|
|
|
|
|
*/ |
|
|
|
|
|
GUILayout.BeginHorizontal(); |
|
|
{ |
|
|
GUILayout.FlexibleSpace(); |
|
|
if (GUILayout.Button("Copy properties to\nselected Object(s)", GUILayout.Height(Mathf.Ceil(EditorGUIUtility.singleLineHeight * 2.1f)))) |
|
|
{ |
|
|
bool foundPs = false; |
|
|
foreach (GameObject go in Selection.gameObjects) |
|
|
{ |
|
|
var system = go.GetComponent<ParticleSystem>(); |
|
|
if (system != null) |
|
|
{ |
|
|
foundPs = true; |
|
|
CopyModules(copyModulesSourceParticleSystem, system); |
|
|
} |
|
|
} |
|
|
|
|
|
if (!foundPs) |
|
|
{ |
|
|
EditorApplication.Beep(); |
|
|
Debug.LogWarning("Cartoon FX Easy Editor: No Particle System found in the selected GameObject(s)!"); |
|
|
} |
|
|
} |
|
|
} |
|
|
GUILayout.EndHorizontal(); |
|
|
} |
|
|
|
|
|
/* |
|
|
|
|
|
GUISeparator(); |
|
|
|
|
|
// TODO full list of the Properties with saving/loading presets |
|
|
|
|
|
mutateFoldout = EditorGUILayout.Foldout(mutateFoldout, "MUTATE MODULES", true); |
|
|
if (mutateFoldout) |
|
|
{ |
|
|
GUILayout.Space(4); |
|
|
|
|
|
DrawSelectableModules(ref selectedModulesMutate, ref enabledModulesMutate, selectedParticleSystem); |
|
|
|
|
|
EditorGUI.BeginChangeCheck(); |
|
|
float newValue = EditorGUILayout.Slider("<EFBFBD> percent", Mathf.Floor(mutatePercentage * 100), 0, 100); |
|
|
if (EditorGUI.EndChangeCheck()) |
|
|
{ |
|
|
mutatePercentage = newValue / 100f; |
|
|
} |
|
|
|
|
|
if (GUILayout.Button("Mutate Modules", GUILayout.Height(EditorGUIUtility.singleLineHeight*2.1f))) |
|
|
{ |
|
|
MutateModules(); |
|
|
} |
|
|
} |
|
|
|
|
|
*/ |
|
|
|
|
|
//---------------------------------------------------------------- |
|
|
|
|
|
GUILayout.Space(8); |
|
|
|
|
|
//Resize window if needed |
|
|
if (Event.current.type == EventType.Repaint) |
|
|
{ |
|
|
float h = GUILayoutUtility.GetLastRect().yMax; |
|
|
if (lastHeight != h) |
|
|
{ |
|
|
lastHeight = h; |
|
|
this.minSize = new Vector2(300, h); |
|
|
this.maxSize = new Vector2(300, h); |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
float lastHeight = 0; |
|
|
|
|
|
void DrawSelectableModules(ref bool[] selected, ref bool[] enabled, ParticleSystem target) |
|
|
{ |
|
|
if (modulesToCopy != null) |
|
|
{ |
|
|
if (enabled == null || enabled.Length != modulesToCopy.Length) |
|
|
{ |
|
|
enabled = new bool[modulesToCopy.Length]; |
|
|
} |
|
|
|
|
|
|
|
|
// +1 for the Renderer component |
|
|
if (selected == null || selected.Length != (modulesToCopy.Length + 1)) |
|
|
{ |
|
|
selected = new bool[modulesToCopy.Length + 1]; |
|
|
} |
|
|
int renderer = selected.Length - 1; |
|
|
|
|
|
// quick select: |
|
|
GUILayout.BeginHorizontal(); |
|
|
GUILayout.Label("Select:", GUILayout.Width(60)); |
|
|
if (GUILayout.Button(" All ", EditorStyles.miniButton)) |
|
|
{ |
|
|
for (int i = 0; i < modulesToCopy.Length; i++) |
|
|
{ |
|
|
if (!pref_HideDisabledModulesCopy || enabled[i]) |
|
|
{ |
|
|
selected[i] = true; |
|
|
} |
|
|
selected[renderer] = true; |
|
|
} |
|
|
} |
|
|
|
|
|
var guiColor = GUI.color; |
|
|
GUI.color *= new Color(1.0f, 0.5f, 0.5f); |
|
|
if (GUILayout.Button(" None ", EditorStyles.miniButton)) |
|
|
{ |
|
|
for (int i = 0; i < modulesToCopy.Length; i++) |
|
|
{ |
|
|
selected[i] = false; |
|
|
} |
|
|
selected[renderer] = false; |
|
|
} |
|
|
GUILayout.EndHorizontal(); |
|
|
GUI.color = guiColor; |
|
|
|
|
|
GUILayout.BeginHorizontal(); |
|
|
GUILayout.Label(" ", GUILayout.Width(60)); |
|
|
if (GUILayout.Button(" Size ", EditorStyles.miniButton)) |
|
|
{ |
|
|
for (int i = 0; i < modulesToCopy.Length; i++) |
|
|
{ |
|
|
switch (modulesToCopy[i].serializedPropertyPath) |
|
|
{ |
|
|
case "SizeModule": |
|
|
case "SizeBySpeedModule": |
|
|
selected[i] = true; |
|
|
break; |
|
|
} |
|
|
} |
|
|
} |
|
|
if (GUILayout.Button(" Movement ", EditorStyles.miniButton)) |
|
|
{ |
|
|
for (int i = 0; i < modulesToCopy.Length; i++) |
|
|
{ |
|
|
switch (modulesToCopy[i].serializedPropertyPath) |
|
|
{ |
|
|
case "VelocityModule": |
|
|
case "InheritVelocityModule": |
|
|
case "ForceModule": |
|
|
case "ExternalForcesModule": |
|
|
case "ClampVelocityModule": |
|
|
case "NoiseModule": |
|
|
case "CollisionModule": |
|
|
selected[i] = true; |
|
|
break; |
|
|
} |
|
|
} |
|
|
} |
|
|
if (GUILayout.Button(" Color/Appearance ", EditorStyles.miniButton)) |
|
|
{ |
|
|
for (int i = 0; i < modulesToCopy.Length; i++) |
|
|
{ |
|
|
switch (modulesToCopy[i].serializedPropertyPath) |
|
|
{ |
|
|
case "ColorModule": |
|
|
case "ColorBySpeedModule": |
|
|
case "TrailModule": |
|
|
case "LightsModule": |
|
|
case "UVModule": |
|
|
selected[i] = true; |
|
|
break; |
|
|
} |
|
|
selected[renderer] = true; |
|
|
} |
|
|
} |
|
|
GUILayout.EndHorizontal(); |
|
|
|
|
|
using (new EditorGUI.DisabledScope(target == null)) |
|
|
{ |
|
|
EditorGUI.BeginChangeCheck(); |
|
|
pref_HideDisabledModulesCopy = GUILayout.Toggle(pref_HideDisabledModulesCopy, new GUIContent(" Hide disabled modules", "Will hide modules that are disabled on the current source Particle System")); |
|
|
if (EditorGUI.EndChangeCheck()) |
|
|
{ |
|
|
EditorPrefs.SetBool("CFX_HideDisabledModulesCopy", pref_HideDisabledModulesCopy); |
|
|
RefreshCurrentlyEnabledModules(target, ref enabled); |
|
|
} |
|
|
} |
|
|
|
|
|
const int row = 4; |
|
|
const int padding = 4; |
|
|
for (int i = 0; i < modulesToCopy.Length; i += row) |
|
|
{ |
|
|
GUILayout.BeginHorizontal(); |
|
|
{ |
|
|
GUILayout.Space(padding); |
|
|
for (int j = 0; j < row; j++) |
|
|
{ |
|
|
if (i+j < modulesLabels.Length) |
|
|
{ |
|
|
var col = GUI.color; |
|
|
|
|
|
// special case: renderer |
|
|
/* |
|
|
if (i+j == modulesLabels.Length-1) |
|
|
{ |
|
|
if (selectedModuleRenderer) GUI.color *= Color.cyan; |
|
|
selectedModuleRenderer = GUILayout.Toggle(selectedModuleRenderer, modulesLabels[i+j], EditorStyles.toolbarButton); |
|
|
} |
|
|
else |
|
|
*/ |
|
|
{ |
|
|
bool enbl = (i+j) >= enabled.Length ? true : enabled[i+j]; |
|
|
if (pref_HideDisabledModulesCopy && !enbl) |
|
|
{ |
|
|
continue; |
|
|
} |
|
|
if (selected[i+j]) GUI.color *= Color.cyan; |
|
|
selected[i+j] = GUILayout.Toggle(selected[i+j], modulesLabels[i+j], EditorStyles.toolbarButton); |
|
|
} |
|
|
GUI.color = col; |
|
|
} |
|
|
} |
|
|
GUILayout.Space(padding); |
|
|
} |
|
|
GUILayout.EndHorizontal(); |
|
|
} |
|
|
} |
|
|
else |
|
|
{ |
|
|
EditorGUILayout.HelpBox("Select a Particle System to initialize the module list.", MessageType.Info); |
|
|
} |
|
|
} |
|
|
|
|
|
void RefreshCurrentlyEnabledModules(ParticleSystem source, ref bool[] enabledModules) |
|
|
{ |
|
|
if (modulesToCopy == null) |
|
|
{ |
|
|
return; |
|
|
} |
|
|
|
|
|
if (enabledModules == null || enabledModules.Length != modulesToCopy.Length) |
|
|
{ |
|
|
// note: no need for extra slot for renderer, consider it always enabled |
|
|
enabledModules = new bool[modulesToCopy.Length]; |
|
|
} |
|
|
|
|
|
if (source != null) |
|
|
{ |
|
|
var so = new SerializedObject(source); |
|
|
for (int i = 0; i < modulesToCopy.Length; i++) |
|
|
{ |
|
|
enabledModules[i] = modulesToCopy[i].CheckIfEnabledInSource(so); |
|
|
} |
|
|
} |
|
|
else |
|
|
{ |
|
|
for (int i = 0; i < enabledModules.Length; i++) |
|
|
{ |
|
|
enabledModules[i] = true; |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
//Loop effects |
|
|
private void loopEffect(bool setLoop) |
|
|
{ |
|
|
foreach(GameObject go in Selection.gameObjects) |
|
|
{ |
|
|
//Scale Shuriken Particles Values |
|
|
ParticleSystem[] systems; |
|
|
if(pref_IncludeChildren) |
|
|
systems = go.GetComponentsInChildren<ParticleSystem>(true); |
|
|
else |
|
|
systems = go.GetComponents<ParticleSystem>(); |
|
|
|
|
|
foreach(ParticleSystem ps in systems) |
|
|
{ |
|
|
SerializedObject so = new SerializedObject(ps); |
|
|
so.FindProperty("looping").boolValue = setLoop; |
|
|
so.ApplyModifiedProperties(); |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
//Prewarm effects |
|
|
private void prewarmEffect(bool setPrewarm) |
|
|
{ |
|
|
foreach(GameObject go in Selection.gameObjects) |
|
|
{ |
|
|
//Scale Shuriken Particles Values |
|
|
ParticleSystem[] systems; |
|
|
if(pref_IncludeChildren) |
|
|
systems = go.GetComponentsInChildren<ParticleSystem>(true); |
|
|
else |
|
|
systems = go.GetComponents<ParticleSystem>(); |
|
|
|
|
|
foreach(ParticleSystem ps in systems) |
|
|
{ |
|
|
SerializedObject so = new SerializedObject(ps); |
|
|
so.FindProperty("prewarm").boolValue = setPrewarm; |
|
|
so.ApplyModifiedProperties(); |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
//Scale Size |
|
|
private void applyScale() |
|
|
{ |
|
|
Undo.IncrementCurrentGroup(); |
|
|
int groupId = Undo.GetCurrentGroup(); |
|
|
|
|
|
foreach(GameObject go in Selection.gameObjects) |
|
|
{ |
|
|
//Scale Shuriken Particles Values |
|
|
ParticleSystem[] systems; |
|
|
if(pref_IncludeChildren) |
|
|
systems = go.GetComponentsInChildren<ParticleSystem>(true); |
|
|
else |
|
|
systems = go.GetComponents<ParticleSystem>(); |
|
|
|
|
|
foreach(ParticleSystem ps in systems) |
|
|
{ |
|
|
Undo.RegisterCompleteObjectUndo(ps, "Apply Particle Scale"); |
|
|
Undo.RegisterCompleteObjectUndo(ps.transform, "Apply Particle Scale"); |
|
|
ScaleParticleValues(ps, go); |
|
|
} |
|
|
|
|
|
//Scale Lights' range |
|
|
Light[] lights = go.GetComponentsInChildren<Light>(); |
|
|
foreach(Light light in lights) |
|
|
{ |
|
|
Undo.RegisterCompleteObjectUndo(light, "Apply Particle Scale"); |
|
|
Undo.RegisterCompleteObjectUndo(light.transform, "Apply Particle Scale"); |
|
|
light.range *= ScalingValue; |
|
|
light.transform.localPosition *= ScalingValue; |
|
|
} |
|
|
} |
|
|
|
|
|
Undo.CollapseUndoOperations(groupId); |
|
|
} |
|
|
|
|
|
//Change Color |
|
|
private void applyColor() |
|
|
{ |
|
|
foreach(GameObject go in Selection.gameObjects) |
|
|
{ |
|
|
ParticleSystem[] systems; |
|
|
if(pref_IncludeChildren) |
|
|
systems = go.GetComponentsInChildren<ParticleSystem>(true); |
|
|
else |
|
|
systems = go.GetComponents<ParticleSystem>(); |
|
|
|
|
|
foreach(ParticleSystem ps in systems) |
|
|
{ |
|
|
SerializedObject psSerial = new SerializedObject(ps); |
|
|
if(!AffectAlpha) |
|
|
{ |
|
|
psSerial.FindProperty("InitialModule.startColor.maxColor").colorValue = new Color(ColorValue.r, ColorValue.g, ColorValue.b, psSerial.FindProperty("InitialModule.startColor.maxColor").colorValue.a); |
|
|
psSerial.FindProperty("InitialModule.startColor.minColor").colorValue = new Color(ColorValue2.r, ColorValue2.g, ColorValue2.b, psSerial.FindProperty("InitialModule.startColor.minColor").colorValue.a); |
|
|
} |
|
|
else |
|
|
{ |
|
|
psSerial.FindProperty("InitialModule.startColor.maxColor").colorValue = ColorValue; |
|
|
psSerial.FindProperty("InitialModule.startColor.minColor").colorValue = ColorValue2; |
|
|
} |
|
|
psSerial.ApplyModifiedProperties(); |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
//TINT COLORS ================================================================================================================================ |
|
|
|
|
|
private void tintColor() |
|
|
{ |
|
|
float hue = HSLColor.FromRGBA(TintColorValue).h; |
|
|
GenericProcessColors(color => |
|
|
{ |
|
|
return HSLColor.FromRGBA(color).ColorWithHue(hue, false); |
|
|
}); |
|
|
} |
|
|
|
|
|
private void hueShift() |
|
|
{ |
|
|
GenericProcessColors(color => |
|
|
{ |
|
|
return HSLColor.FromRGBA(color).ColorWithHue(TintHueShiftValue, true); |
|
|
}); |
|
|
} |
|
|
|
|
|
private void satShift() |
|
|
{ |
|
|
GenericProcessColors(color => |
|
|
{ |
|
|
return HSLColor.FromRGBA(color).ColorWithSaturationOffset(SatShiftValue); |
|
|
}); |
|
|
} |
|
|
|
|
|
private void valShift() |
|
|
{ |
|
|
GenericProcessColors(color => |
|
|
{ |
|
|
return HSLColor.FromRGBA(color).ColorWithLightnessOffset(ValShiftValue); |
|
|
}); |
|
|
} |
|
|
|
|
|
private void GenericTintColorProperty(SerializedProperty colorProperty, float hue, bool shift) |
|
|
{ |
|
|
GenericEditColorProperty(colorProperty, color => |
|
|
{ |
|
|
return HSLColor.FromRGBA(color).ColorWithHue(hue, shift); |
|
|
}); |
|
|
} |
|
|
|
|
|
private void GenericEditGradient(SerializedProperty gradientProperty, System.Func<Color, Color> callback) |
|
|
{ |
|
|
gradientProperty.FindPropertyRelative("key0").colorValue = callback(gradientProperty.FindPropertyRelative("key0").colorValue); |
|
|
gradientProperty.FindPropertyRelative("key1").colorValue = callback(gradientProperty.FindPropertyRelative("key1").colorValue); |
|
|
gradientProperty.FindPropertyRelative("key2").colorValue = callback(gradientProperty.FindPropertyRelative("key2").colorValue); |
|
|
gradientProperty.FindPropertyRelative("key3").colorValue = callback(gradientProperty.FindPropertyRelative("key3").colorValue); |
|
|
gradientProperty.FindPropertyRelative("key4").colorValue = callback(gradientProperty.FindPropertyRelative("key4").colorValue); |
|
|
gradientProperty.FindPropertyRelative("key5").colorValue = callback(gradientProperty.FindPropertyRelative("key5").colorValue); |
|
|
gradientProperty.FindPropertyRelative("key6").colorValue = callback(gradientProperty.FindPropertyRelative("key6").colorValue); |
|
|
gradientProperty.FindPropertyRelative("key7").colorValue = callback(gradientProperty.FindPropertyRelative("key7").colorValue); |
|
|
} |
|
|
|
|
|
private void gammaToLinear() |
|
|
{ |
|
|
GenericProcessColors(color => |
|
|
{ |
|
|
return color.gamma; |
|
|
}); |
|
|
} |
|
|
|
|
|
private void linearToGamma() |
|
|
{ |
|
|
GenericProcessColors(color => |
|
|
{ |
|
|
return color.linear; |
|
|
}); |
|
|
} |
|
|
|
|
|
private void GenericProcessColors(System.Func<Color, Color> callback) |
|
|
{ |
|
|
foreach (GameObject go in Selection.gameObjects) |
|
|
{ |
|
|
ParticleSystem[] systems; |
|
|
if (pref_IncludeChildren) |
|
|
systems = go.GetComponentsInChildren<ParticleSystem>(true); |
|
|
else |
|
|
systems = go.GetComponents<ParticleSystem>(); |
|
|
|
|
|
foreach (ParticleSystem ps in systems) |
|
|
{ |
|
|
SerializedObject psSerial = new SerializedObject(ps); |
|
|
|
|
|
if (TintStartColor) GenericEditColorProperty(psSerial.FindProperty("InitialModule.startColor"), callback); |
|
|
if (TintColorModule) GenericEditColorProperty(psSerial.FindProperty("ColorModule.gradient"), callback); |
|
|
if (TintColorSpeedModule) GenericEditColorProperty(psSerial.FindProperty("ColorBySpeedModule.gradient"), callback); |
|
|
if (TintCustomData1) GenericEditColorProperty(psSerial.FindProperty("CustomDataModule.color0"), callback); |
|
|
if (TintCustomData2) GenericEditColorProperty(psSerial.FindProperty("CustomDataModule.color1"), callback); |
|
|
|
|
|
psSerial.ApplyModifiedProperties(); |
|
|
} |
|
|
|
|
|
if (TintLights) |
|
|
{ |
|
|
var lights = go.GetComponentsInChildren<Light>(); |
|
|
foreach (var light in lights) |
|
|
{ |
|
|
var psLight = new SerializedObject(light); |
|
|
var colorProperty = psLight.FindProperty("m_Color"); |
|
|
colorProperty.colorValue = callback(colorProperty.colorValue); |
|
|
psLight.ApplyModifiedProperties(); |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
private void GenericEditColorProperty(SerializedProperty colorProperty, System.Func<Color, Color> callback) |
|
|
{ |
|
|
int state = colorProperty.FindPropertyRelative("minMaxState").intValue; |
|
|
switch (state) |
|
|
{ |
|
|
//Constant Color |
|
|
case 0: |
|
|
colorProperty.FindPropertyRelative("maxColor").colorValue = callback(colorProperty.FindPropertyRelative("maxColor").colorValue); |
|
|
break; |
|
|
|
|
|
//Gradient |
|
|
case 1: |
|
|
GenericEditGradient(colorProperty.FindPropertyRelative("maxGradient"), callback); |
|
|
break; |
|
|
|
|
|
//Random between 2 Colors |
|
|
case 2: |
|
|
colorProperty.FindPropertyRelative("minColor").colorValue = callback(colorProperty.FindPropertyRelative("minColor").colorValue); |
|
|
colorProperty.FindPropertyRelative("maxColor").colorValue = callback(colorProperty.FindPropertyRelative("maxColor").colorValue); |
|
|
break; |
|
|
|
|
|
//Random between 2 Gradients |
|
|
case 3: |
|
|
GenericEditGradient(colorProperty.FindPropertyRelative("maxGradient"), callback); |
|
|
GenericEditGradient(colorProperty.FindPropertyRelative("minGradient"), callback); |
|
|
break; |
|
|
} |
|
|
} |
|
|
|
|
|
//LIGHTNESS OFFSET ================================================================================================================================ |
|
|
|
|
|
private void addLightness(bool substract) |
|
|
{ |
|
|
if(!TintStartColor && !TintColorModule && !TintColorSpeedModule) |
|
|
{ |
|
|
Debug.LogWarning("Cartoon FX Easy Editor: You must toggle at least one of the three Color Modules to be able to change lightness!"); |
|
|
return; |
|
|
} |
|
|
|
|
|
float lightness = (float)(LightnessStep/100f); |
|
|
if(substract) |
|
|
lightness *= -1f; |
|
|
|
|
|
foreach(GameObject go in Selection.gameObjects) |
|
|
{ |
|
|
ParticleSystem[] systems; |
|
|
if(pref_IncludeChildren) |
|
|
systems = go.GetComponentsInChildren<ParticleSystem>(true); |
|
|
else |
|
|
systems = go.GetComponents<ParticleSystem>(); |
|
|
|
|
|
foreach(ParticleSystem ps in systems) |
|
|
{ |
|
|
SerializedObject psSerial = new SerializedObject(ps); |
|
|
|
|
|
if(TintStartColor) |
|
|
GenericAddLightness(psSerial.FindProperty("InitialModule.startColor"), lightness); |
|
|
|
|
|
if(TintColorModule) |
|
|
GenericAddLightness(psSerial.FindProperty("ColorModule.gradient"), lightness); |
|
|
|
|
|
if(TintColorSpeedModule) |
|
|
GenericAddLightness(psSerial.FindProperty("ColorBySpeedModule.gradient"), lightness); |
|
|
|
|
|
psSerial.ApplyModifiedProperties(); |
|
|
psSerial.Update(); |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
private void GenericAddLightness(SerializedProperty colorProperty, float lightness) |
|
|
{ |
|
|
int state = colorProperty.FindPropertyRelative("minMaxState").intValue; |
|
|
switch(state) |
|
|
{ |
|
|
//Constant Color |
|
|
case 0: |
|
|
colorProperty.FindPropertyRelative("maxColor").colorValue = HSLColor.FromRGBA(colorProperty.FindPropertyRelative("maxColor").colorValue).ColorWithLightnessOffset(lightness); |
|
|
break; |
|
|
|
|
|
//Gradient |
|
|
case 1: |
|
|
AddLightnessGradient(colorProperty.FindPropertyRelative("maxGradient"), lightness); |
|
|
break; |
|
|
|
|
|
//Random between 2 Colors |
|
|
case 2: |
|
|
colorProperty.FindPropertyRelative("minColor").colorValue = HSLColor.FromRGBA(colorProperty.FindPropertyRelative("minColor").colorValue).ColorWithLightnessOffset(lightness); |
|
|
colorProperty.FindPropertyRelative("maxColor").colorValue = HSLColor.FromRGBA(colorProperty.FindPropertyRelative("maxColor").colorValue).ColorWithLightnessOffset(lightness); |
|
|
break; |
|
|
|
|
|
//Random between 2 Gradients |
|
|
case 3: |
|
|
AddLightnessGradient(colorProperty.FindPropertyRelative("maxGradient"), lightness); |
|
|
AddLightnessGradient(colorProperty.FindPropertyRelative("minGradient"), lightness); |
|
|
break; |
|
|
} |
|
|
} |
|
|
|
|
|
private void AddLightnessGradient(SerializedProperty gradientProperty, float lightness) |
|
|
{ |
|
|
gradientProperty.FindPropertyRelative("key0").colorValue = HSLColor.FromRGBA(gradientProperty.FindPropertyRelative("key0").colorValue).ColorWithLightnessOffset(lightness); |
|
|
gradientProperty.FindPropertyRelative("key1").colorValue = HSLColor.FromRGBA(gradientProperty.FindPropertyRelative("key1").colorValue).ColorWithLightnessOffset(lightness); |
|
|
gradientProperty.FindPropertyRelative("key2").colorValue = HSLColor.FromRGBA(gradientProperty.FindPropertyRelative("key2").colorValue).ColorWithLightnessOffset(lightness); |
|
|
gradientProperty.FindPropertyRelative("key3").colorValue = HSLColor.FromRGBA(gradientProperty.FindPropertyRelative("key3").colorValue).ColorWithLightnessOffset(lightness); |
|
|
gradientProperty.FindPropertyRelative("key4").colorValue = HSLColor.FromRGBA(gradientProperty.FindPropertyRelative("key4").colorValue).ColorWithLightnessOffset(lightness); |
|
|
gradientProperty.FindPropertyRelative("key5").colorValue = HSLColor.FromRGBA(gradientProperty.FindPropertyRelative("key5").colorValue).ColorWithLightnessOffset(lightness); |
|
|
gradientProperty.FindPropertyRelative("key6").colorValue = HSLColor.FromRGBA(gradientProperty.FindPropertyRelative("key6").colorValue).ColorWithLightnessOffset(lightness); |
|
|
gradientProperty.FindPropertyRelative("key7").colorValue = HSLColor.FromRGBA(gradientProperty.FindPropertyRelative("key7").colorValue).ColorWithLightnessOffset(lightness); |
|
|
} |
|
|
|
|
|
//RGB / HSL Conversions |
|
|
private struct HSLColor |
|
|
{ |
|
|
public float h; |
|
|
public float s; |
|
|
public float l; |
|
|
public float a; |
|
|
|
|
|
public HSLColor(float h, float s, float l, float a) |
|
|
{ |
|
|
this.h = h; |
|
|
this.s = s; |
|
|
this.l = l; |
|
|
this.a = a; |
|
|
} |
|
|
|
|
|
public HSLColor(float h, float s, float l) |
|
|
{ |
|
|
this.h = h; |
|
|
this.s = s; |
|
|
this.l = l; |
|
|
this.a = 1f; |
|
|
} |
|
|
|
|
|
public HSLColor(Color c) |
|
|
{ |
|
|
HSLColor temp = FromRGBA(c); |
|
|
h = temp.h; |
|
|
s = temp.s; |
|
|
l = temp.l; |
|
|
a = temp.a; |
|
|
} |
|
|
|
|
|
public static HSLColor FromRGBA(Color c) |
|
|
{ |
|
|
float h, s, l, a; |
|
|
a = c.a; |
|
|
|
|
|
float cmin = Mathf.Min(Mathf.Min(c.r, c.g), c.b); |
|
|
float cmax = Mathf.Max(Mathf.Max(c.r, c.g), c.b); |
|
|
|
|
|
l = (cmin + cmax) / 2f; |
|
|
|
|
|
if (cmin == cmax) |
|
|
{ |
|
|
s = 0; |
|
|
h = 0; |
|
|
} |
|
|
else |
|
|
{ |
|
|
float delta = cmax - cmin; |
|
|
|
|
|
s = (l <= .5f) ? (delta / (cmax + cmin)) : (delta / (2f - (cmax + cmin))); |
|
|
|
|
|
h = 0; |
|
|
|
|
|
if (c.r == cmax) |
|
|
{ |
|
|
h = (c.g - c.b) / delta; |
|
|
} |
|
|
else if (c.g == cmax) |
|
|
{ |
|
|
h = 2f + (c.b - c.r) / delta; |
|
|
} |
|
|
else if (c.b == cmax) |
|
|
{ |
|
|
h = 4f + (c.r - c.g) / delta; |
|
|
} |
|
|
|
|
|
h = Mathf.Repeat(h * 60f, 360f); |
|
|
} |
|
|
|
|
|
return new HSLColor(h, s, l, a); |
|
|
} |
|
|
|
|
|
public Color ToRGBA() |
|
|
{ |
|
|
float r, g, b, a; |
|
|
a = this.a; |
|
|
|
|
|
float m1, m2; |
|
|
|
|
|
m2 = (l <= .5f) ? (l * (1f + s)) : (l + s - l * s); |
|
|
m1 = 2f * l - m2; |
|
|
|
|
|
if (s == 0f) |
|
|
{ |
|
|
r = g = b = l; |
|
|
} |
|
|
else |
|
|
{ |
|
|
r = Value(m1, m2, h + 120f); |
|
|
g = Value(m1, m2, h); |
|
|
b = Value(m1, m2, h - 120f); |
|
|
} |
|
|
|
|
|
return new Color(r, g, b, a); |
|
|
} |
|
|
|
|
|
static float Value(float n1, float n2, float hue) |
|
|
{ |
|
|
hue = Mathf.Repeat(hue, 360f); |
|
|
|
|
|
if (hue < 60f) |
|
|
{ |
|
|
return n1 + (n2 - n1) * hue / 60f; |
|
|
} |
|
|
else if (hue < 180f) |
|
|
{ |
|
|
return n2; |
|
|
} |
|
|
else if (hue < 240f) |
|
|
{ |
|
|
return n1 + (n2 - n1) * (240f - hue) / 60f; |
|
|
} |
|
|
else |
|
|
{ |
|
|
return n1; |
|
|
} |
|
|
} |
|
|
|
|
|
public Color VividColor() |
|
|
{ |
|
|
this.l = 0.5f; |
|
|
this.s = 1.0f; |
|
|
return this.ToRGBA(); |
|
|
} |
|
|
|
|
|
public Color ColorWithHue(float hue, bool shift) |
|
|
{ |
|
|
if(shift) |
|
|
{ |
|
|
this.h += hue; |
|
|
while(this.h >= 360f) |
|
|
this.h -= 360f; |
|
|
while(this.h <= -360f) |
|
|
this.h += 360f; |
|
|
} |
|
|
else |
|
|
this.h = hue; |
|
|
|
|
|
return this.ToRGBA(); |
|
|
} |
|
|
|
|
|
public Color ColorWithLightnessOffset(float lightness) |
|
|
{ |
|
|
this.l += lightness; |
|
|
if(this.l > 1.0f) this.l = 1.0f; |
|
|
else if(this.l < 0.0f) this.l = 0.0f; |
|
|
|
|
|
return this.ToRGBA(); |
|
|
} |
|
|
|
|
|
public Color ColorWithSaturationOffset(float saturation) |
|
|
{ |
|
|
this.s += saturation; |
|
|
if(this.s > 1.0f) this.s = 1.0f; |
|
|
else if(this.s < 0.0f) this.s = 0.0f; |
|
|
|
|
|
return this.ToRGBA(); |
|
|
} |
|
|
|
|
|
public static implicit operator HSLColor(Color src) |
|
|
{ |
|
|
return FromRGBA(src); |
|
|
} |
|
|
|
|
|
public static implicit operator Color(HSLColor src) |
|
|
{ |
|
|
return src.ToRGBA(); |
|
|
} |
|
|
} |
|
|
|
|
|
//Scale Lifetime only |
|
|
private void applySpeed() |
|
|
{ |
|
|
foreach(GameObject go in Selection.gameObjects) |
|
|
{ |
|
|
ParticleSystem[] systems; |
|
|
if(pref_IncludeChildren) |
|
|
systems = go.GetComponentsInChildren<ParticleSystem>(true); |
|
|
else |
|
|
systems = go.GetComponents<ParticleSystem>(); |
|
|
|
|
|
//Scale Lifetime |
|
|
foreach(ParticleSystem ps in systems) |
|
|
{ |
|
|
#if UNITY_5_5_OR_NEWER |
|
|
var main = ps.main; |
|
|
main.simulationSpeed = LTScalingValue; |
|
|
#else |
|
|
ps.playbackSpeed = LTScalingValue; |
|
|
#endif |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
//Set Duration |
|
|
private void applyDuration() |
|
|
{ |
|
|
foreach(GameObject go in Selection.gameObjects) |
|
|
{ |
|
|
//Scale Shuriken Particles Values |
|
|
ParticleSystem[] systems; |
|
|
if(pref_IncludeChildren) |
|
|
systems = go.GetComponentsInChildren<ParticleSystem>(true); |
|
|
else |
|
|
systems = go.GetComponents<ParticleSystem>(); |
|
|
|
|
|
foreach(ParticleSystem ps in systems) |
|
|
{ |
|
|
SerializedObject so = new SerializedObject(ps); |
|
|
so.FindProperty("lengthInSec").floatValue = DurationValue; |
|
|
so.ApplyModifiedProperties(); |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
//Change delay |
|
|
private void applyDelay() |
|
|
{ |
|
|
foreach(GameObject go in Selection.gameObjects) |
|
|
{ |
|
|
ParticleSystem[] systems; |
|
|
if(pref_IncludeChildren) |
|
|
systems = go.GetComponentsInChildren<ParticleSystem>(true); |
|
|
else |
|
|
systems = go.GetComponents<ParticleSystem>(); |
|
|
|
|
|
//Scale Lifetime |
|
|
foreach(ParticleSystem ps in systems) |
|
|
{ |
|
|
#if UNITY_5_5_OR_NEWER |
|
|
var main = ps.main; |
|
|
main.startDelay = DelayValue; |
|
|
#else |
|
|
ps.startDelay = DelayValue; |
|
|
#endif |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
//Copy Selected Modules |
|
|
private void CopyModules(ParticleSystem source, ParticleSystem dest) |
|
|
{ |
|
|
if(source == null) |
|
|
{ |
|
|
Debug.LogWarning("Cartoon FX Easy Editor: Select a source Particle System to copy properties from first!"); |
|
|
return; |
|
|
} |
|
|
|
|
|
SerializedObject psSource = new SerializedObject(source); |
|
|
SerializedObject psDest = new SerializedObject(dest); |
|
|
|
|
|
for (int i = 0; i < modulesToCopy.Length; i++) |
|
|
{ |
|
|
var module = modulesToCopy[i]; |
|
|
|
|
|
if (!selectedModules[i]) |
|
|
{ |
|
|
continue; |
|
|
} |
|
|
|
|
|
var sp = psSource.FindProperty(module.serializedPropertyPath); |
|
|
if (sp == null) |
|
|
{ |
|
|
Debug.LogError("Couldn't find module in SerializedObject: " + module.serializedPropertyPath); |
|
|
continue; |
|
|
} |
|
|
|
|
|
psDest.CopyFromSerializedProperty(sp); |
|
|
|
|
|
// special case: extra properties for initial module |
|
|
if (i == 0) |
|
|
{ |
|
|
foreach (var path in initialModuleExtraProperties) |
|
|
{ |
|
|
var extraSp = psSource.FindProperty(path); |
|
|
if (extraSp != null) |
|
|
{ |
|
|
psDest.CopyFromSerializedProperty(extraSp); |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
psDest.ApplyModifiedProperties(); |
|
|
} |
|
|
|
|
|
//Renderer |
|
|
if (selectedModules[selectedModules.Length-1]) |
|
|
{ |
|
|
ParticleSystemRenderer rendSource = source.GetComponent<ParticleSystemRenderer>(); |
|
|
ParticleSystemRenderer rendDest = dest.GetComponent<ParticleSystemRenderer>(); |
|
|
UnityEditorInternal.ComponentUtility.CopyComponent(rendSource); |
|
|
UnityEditorInternal.ComponentUtility.PasteComponentValues(rendDest); |
|
|
} |
|
|
} |
|
|
|
|
|
/* |
|
|
private void MutateModules() |
|
|
{ |
|
|
var systems = pref_IncludeChildren ? Selection.activeGameObject.GetComponentsInChildren<ParticleSystem>() : Selection.activeGameObject.GetComponents<ParticleSystem>(); |
|
|
var so = new SerializedObject(systems); |
|
|
|
|
|
for (int i = 0; i < modulesToCopy.Length; i++) |
|
|
{ |
|
|
if (!selectedModulesMutate[i]) |
|
|
{ |
|
|
continue; |
|
|
} |
|
|
|
|
|
var sp = so.FindProperty(modulesToCopy[i].serializedPropertyPath); |
|
|
if (sp != null) |
|
|
{ |
|
|
if (sp.FindPropertyRelative("enabled").boolValue) |
|
|
{ |
|
|
GenericMutateProperty(sp); |
|
|
sp.serializedObject.ApplyModifiedProperties(); |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
private void GenericMutateProperty(SerializedProperty sp, bool recursive = true) |
|
|
{ |
|
|
System.Func<int, int> randomizeInt = intValue => |
|
|
{ |
|
|
return intValue + Mathf.RoundToInt(intValue * Random.Range(-mutatePercentage, +mutatePercentage)); |
|
|
}; |
|
|
System.Func<float, float> randomizeFloat = floatValue => |
|
|
{ |
|
|
return floatValue + (floatValue * Random.Range(-mutatePercentage, +mutatePercentage)); |
|
|
}; |
|
|
System.Func<float, float> randomizeHue = hueValue => |
|
|
{ |
|
|
hueValue = randomizeFloat(hueValue); |
|
|
while (hueValue > 1) hueValue -= 1; |
|
|
while (hueValue < 0) hueValue += 1; |
|
|
return hueValue; |
|
|
}; |
|
|
|
|
|
//Debug.Log(new string('\t', sp.depth) + sp.name + ": " + sp.type + ", " + sp.propertyType); |
|
|
|
|
|
switch (sp.type) |
|
|
{ |
|
|
case "MinMaxCurve": |
|
|
GenericMutateProperty(sp.FindPropertyRelative("scalar"), false); |
|
|
GenericMutateProperty(sp.FindPropertyRelative("minScalar"), false); |
|
|
return; |
|
|
|
|
|
case "MinMaxGradient": |
|
|
GenericEditColorProperty(sp, color => |
|
|
{ |
|
|
float h, s, v; |
|
|
Color.RGBToHSV(color, out h, out s, out v); |
|
|
h = randomizeHue(h); |
|
|
return Color.HSVToRGB(h, s, v); |
|
|
}); |
|
|
return; |
|
|
} |
|
|
|
|
|
switch (sp.propertyType) |
|
|
{ |
|
|
case SerializedPropertyType.Float: sp.floatValue = randomizeFloat(sp.floatValue); break; |
|
|
case SerializedPropertyType.Integer: sp.intValue = randomizeInt(sp.intValue); break; |
|
|
case SerializedPropertyType.Vector2: sp.vector2Value += new Vector2(randomizeFloat(sp.vector2Value.x), randomizeFloat(sp.vector2Value.y)); break; |
|
|
case SerializedPropertyType.Vector3: sp.vector3Value += new Vector3(randomizeFloat(sp.vector3Value.x), randomizeFloat(sp.vector3Value.y), randomizeFloat(sp.vector3Value.z)); break; |
|
|
case SerializedPropertyType.Vector4: sp.vector4Value += new Vector4(randomizeFloat(sp.vector4Value.x), randomizeFloat(sp.vector4Value.y), randomizeFloat(sp.vector4Value.z), randomizeFloat(sp.vector4Value.w)); break; |
|
|
} |
|
|
|
|
|
if (recursive && sp.hasVisibleChildren) |
|
|
{ |
|
|
var endProp = sp.GetEndProperty(); |
|
|
while (!SerializedProperty.EqualContents(endProp, sp) && sp.NextVisible(true)) |
|
|
{ |
|
|
GenericMutateProperty(sp, false); |
|
|
} |
|
|
} |
|
|
} |
|
|
*/ |
|
|
|
|
|
//Scale System |
|
|
private void ScaleParticleValues(ParticleSystem ps, GameObject parent) |
|
|
{ |
|
|
//Particle System |
|
|
if (ps.gameObject != parent) |
|
|
{ |
|
|
ps.transform.localPosition *= ScalingValue; |
|
|
} |
|
|
|
|
|
SerializedObject psSerial = new SerializedObject(ps); |
|
|
|
|
|
foreach(var path in PropertiesToScale) |
|
|
{ |
|
|
var prop = psSerial.FindProperty(path); |
|
|
if(prop != null) |
|
|
{ |
|
|
if(prop.propertyType == SerializedPropertyType.Float) |
|
|
{ |
|
|
prop.floatValue *= ScalingValue; |
|
|
} |
|
|
else |
|
|
{ |
|
|
Debug.LogWarning("Property in ParticleSystem is not a float: " + path + "\n"); |
|
|
} |
|
|
} |
|
|
else |
|
|
{ |
|
|
Debug.LogWarning("Property doesn't exist in ParticleSystem: " + path + "\n"); |
|
|
} |
|
|
} |
|
|
|
|
|
//Shape Module special case |
|
|
/* |
|
|
if(psSerial.FindProperty("ShapeModule.enabled").boolValue) |
|
|
{ |
|
|
//(ShapeModule.type 6 == Mesh) |
|
|
if(psSerial.FindProperty("ShapeModule.type").intValue == 6) |
|
|
{ |
|
|
//Unity 4+ : changing the Transform scale will affect the shape Mesh |
|
|
ps.transform.localScale = ps.transform.localScale * ScalingValue; |
|
|
EditorUtility.SetDirty(ps.transform); |
|
|
} |
|
|
} |
|
|
*/ |
|
|
|
|
|
//Apply Modified Properties |
|
|
psSerial.ApplyModifiedPropertiesWithoutUndo(); |
|
|
} |
|
|
|
|
|
//Properties to scale, with per-version differences |
|
|
private string[] PropertiesToScale = new string[] |
|
|
{ |
|
|
//Initial |
|
|
"InitialModule.startSize.scalar", |
|
|
"InitialModule.startSpeed.scalar", |
|
|
#if UNITY_2017_1_OR_NEWER |
|
|
"InitialModule.startSize.minScalar", |
|
|
"InitialModule.startSpeed.minScalar", |
|
|
|
|
|
"InitialModule.startSizeY.scalar", |
|
|
"InitialModule.startSizeY.minScalar", |
|
|
"InitialModule.startSizeZ.scalar", |
|
|
"InitialModule.startSizeZ.minScalar", |
|
|
#endif |
|
|
//Size by Speed |
|
|
"SizeBySpeedModule.range.x", |
|
|
"SizeBySpeedModule.range.y", |
|
|
//Velocity over Lifetime |
|
|
"VelocityModule.x.scalar", |
|
|
"VelocityModule.y.scalar", |
|
|
"VelocityModule.z.scalar", |
|
|
#if UNITY_2017_1_OR_NEWER |
|
|
"VelocityModule.x.minScalar", |
|
|
"VelocityModule.y.minScalar", |
|
|
"VelocityModule.z.minScalar", |
|
|
|
|
|
"VelocityModule.orbitalX.scalar", |
|
|
"VelocityModule.orbitalX.minScalar", |
|
|
"VelocityModule.orbitalY.scalar", |
|
|
"VelocityModule.orbitalY.minScalar", |
|
|
"VelocityModule.orbitalZ.scalar", |
|
|
"VelocityModule.orbitalZ.minScalar", |
|
|
|
|
|
"VelocityModule.orbitalOffsetX.scalar", |
|
|
"VelocityModule.orbitalOffsetX.minScalar", |
|
|
"VelocityModule.orbitalOffsetY.scalar", |
|
|
"VelocityModule.orbitalOffsetY.minScalar", |
|
|
"VelocityModule.orbitalOffsetZ.scalar", |
|
|
"VelocityModule.orbitalOffsetZ.minScalar", |
|
|
|
|
|
"VelocityModule.radial.scalar", |
|
|
"VelocityModule.radial.minScalar", |
|
|
|
|
|
"VelocityModule.speedModifier.scalar", |
|
|
"VelocityModule.speedModifier.minScalar", |
|
|
|
|
|
"InheritVelocityModule.m_Curve.scalar", |
|
|
"InheritVelocityModule.m_Curve.minScalar", |
|
|
|
|
|
"ExternalForcesModule.multiplier", |
|
|
|
|
|
"NoiseModule.strength.scalar", |
|
|
"NoiseModule.strength.minScalar", |
|
|
"NoiseModule.strengthY.scalar", |
|
|
"NoiseModule.strengthY.minScalar", |
|
|
"NoiseModule.strengthZ.scalar", |
|
|
"NoiseModule.strengthZ.minScalar", |
|
|
#endif |
|
|
//Limit Velocity over Lifetime |
|
|
"ClampVelocityModule.x.scalar", |
|
|
"ClampVelocityModule.y.scalar", |
|
|
"ClampVelocityModule.z.scalar", |
|
|
#if UNITY_2017_1_OR_NEWER |
|
|
"ClampVelocityModule.x.minScalar", |
|
|
"ClampVelocityModule.y.minScalar", |
|
|
"ClampVelocityModule.z.minScalar", |
|
|
#endif |
|
|
"ClampVelocityModule.magnitude.scalar", |
|
|
//Force over Lifetime |
|
|
"ForceModule.x.scalar", |
|
|
"ForceModule.y.scalar", |
|
|
"ForceModule.z.scalar", |
|
|
#if UNITY_2017_1_OR_NEWER |
|
|
"ForceModule.x.minScalar", |
|
|
"ForceModule.y.minScalar", |
|
|
"ForceModule.z.minScalar", |
|
|
#endif |
|
|
//Special cases per Unity version |
|
|
#if UNITY_2017_1_OR_NEWER |
|
|
"ShapeModule.m_Scale.x", |
|
|
"ShapeModule.m_Scale.y", |
|
|
"ShapeModule.m_Scale.z", |
|
|
#else |
|
|
"ShapeModule.boxX", |
|
|
"ShapeModule.boxY", |
|
|
"ShapeModule.boxZ", |
|
|
#if UNITY_5_6_OR_NEWER |
|
|
"ShapeModule.radius.value", |
|
|
#else |
|
|
"ShapeModule.radius", |
|
|
#endif |
|
|
#endif |
|
|
#if UNITY_5_5_OR_NEWER |
|
|
"EmissionModule.rateOverDistance.scalar", |
|
|
"InitialModule.gravityModifier.scalar", |
|
|
#if UNITY_2017_1_OR_NEWER |
|
|
"EmissionModule.rateOverDistance.minScalar", |
|
|
"InitialModule.gravityModifier.minScalar", |
|
|
#endif |
|
|
#else |
|
|
"InitialModule.gravityModifier", |
|
|
"EmissionModule.rate.scalar", |
|
|
#endif |
|
|
}; |
|
|
|
|
|
void GUISeparator() |
|
|
{ |
|
|
GUILayout.Space(4); |
|
|
if(EditorGUIUtility.isProSkin) |
|
|
{ |
|
|
GUILine(new Color(.15f, .15f, .15f), 1); |
|
|
GUILine(new Color(.4f, .4f, .4f), 1); |
|
|
} |
|
|
else |
|
|
{ |
|
|
GUILine(new Color(.3f, .3f, .3f), 1); |
|
|
GUILine(new Color(.9f, .9f, .9f), 1); |
|
|
} |
|
|
GUILayout.Space(4); |
|
|
} |
|
|
|
|
|
static public void GUILine(Color color, float height = 2f) |
|
|
{ |
|
|
Rect position = GUILayoutUtility.GetRect(0f, float.MaxValue, height, height, LineStyle); |
|
|
|
|
|
if(Event.current.type == EventType.Repaint) |
|
|
{ |
|
|
Color orgColor = GUI.color; |
|
|
GUI.color = orgColor * color; |
|
|
LineStyle.Draw(position, false, false, false, false); |
|
|
GUI.color = orgColor; |
|
|
} |
|
|
} |
|
|
|
|
|
static public GUIStyle _LineStyle; |
|
|
static public GUIStyle LineStyle |
|
|
{ |
|
|
get |
|
|
{ |
|
|
if(_LineStyle == null) |
|
|
{ |
|
|
_LineStyle = new GUIStyle(); |
|
|
_LineStyle.normal.background = EditorGUIUtility.whiteTexture; |
|
|
_LineStyle.stretchWidth = true; |
|
|
} |
|
|
|
|
|
return _LineStyle; |
|
|
} |
|
|
} |
|
|
}
|
|
|
|
