public override void OnInspectorGUI(ParticleSystem s) { EditorGUI.BeginChangeCheck(); bool flag = ModuleUI.GUIToggle(ClampVelocityModuleUI.s_Texts.separateAxes, this.m_SeparateAxes, new GUILayoutOption[0]); if (EditorGUI.EndChangeCheck()) { if (flag) { this.m_Magnitude.RemoveCurveFromEditor(); } else { this.m_X.RemoveCurveFromEditor(); this.m_Y.RemoveCurveFromEditor(); this.m_Z.RemoveCurveFromEditor(); } } SerializedMinMaxCurve arg_88_0 = this.m_Z; MinMaxCurveState state = this.m_X.state; this.m_Y.state = state; arg_88_0.state = state; if (flag) { base.GUITripleMinMaxCurve(GUIContent.none, ClampVelocityModuleUI.s_Texts.x, this.m_X, ClampVelocityModuleUI.s_Texts.y, this.m_Y, ClampVelocityModuleUI.s_Texts.z, this.m_Z, null, new GUILayoutOption[0]); ModuleUI.GUIBoolAsPopup(ClampVelocityModuleUI.s_Texts.space, this.m_InWorldSpace, ClampVelocityModuleUI.s_Texts.spaces, new GUILayoutOption[0]); } else { ModuleUI.GUIMinMaxCurve(ClampVelocityModuleUI.s_Texts.magnitude, this.m_Magnitude, new GUILayoutOption[0]); } ModuleUI.GUIFloat(ClampVelocityModuleUI.s_Texts.dampen, this.m_Dampen, new GUILayoutOption[0]); }
public override void OnInspectorGUI(InitialModuleUI initial) { EditorGUI.BeginChangeCheck(); bool flag = ModuleUI.GUIToggle(RotationByVelocityModuleUI.s_Texts.separateAxes, this.m_SeparateAxes, new GUILayoutOption[0]); if (EditorGUI.EndChangeCheck()) { if (!flag) { this.m_X.RemoveCurveFromEditor(); this.m_Y.RemoveCurveFromEditor(); } } if (!this.m_Z.stateHasMultipleDifferentValues) { this.m_X.SetMinMaxState(this.m_Z.state, flag); this.m_Y.SetMinMaxState(this.m_Z.state, flag); } MinMaxCurveState state = this.m_Z.state; if (flag) { this.m_Z.m_DisplayName = RotationByVelocityModuleUI.s_Texts.z; base.GUITripleMinMaxCurve(GUIContent.none, RotationByVelocityModuleUI.s_Texts.x, this.m_X, RotationByVelocityModuleUI.s_Texts.y, this.m_Y, RotationByVelocityModuleUI.s_Texts.z, this.m_Z, null, new GUILayoutOption[0]); } else { this.m_Z.m_DisplayName = RotationByVelocityModuleUI.s_Texts.rotation; ModuleUI.GUIMinMaxCurve(RotationByVelocityModuleUI.s_Texts.rotation, this.m_Z, new GUILayoutOption[0]); } using (new EditorGUI.DisabledScope(state == MinMaxCurveState.k_Scalar || state == MinMaxCurveState.k_TwoScalars)) { ModuleUI.GUIMinMaxRange(RotationByVelocityModuleUI.s_Texts.velocityRange, this.m_Range, new GUILayoutOption[0]); } }
public static void GUIMMCurveStateList(Rect rect, SerializedMinMaxCurve[] minMaxCurves) { if (!EditorGUI.ButtonMouseDown(rect, GUIContent.none, FocusType.Passive, ParticleSystemStyles.Get().minMaxCurveStateDropDown) || minMaxCurves.Length == 0) { return; } GUIContent[] guiContentArray = new GUIContent[4] { new GUIContent("Constant"), new GUIContent("Curve"), new GUIContent("Random Between Two Constants"), new GUIContent("Random Between Two Curves") }; MinMaxCurveState[] minMaxCurveStateArray = new MinMaxCurveState[4] { MinMaxCurveState.k_Scalar, MinMaxCurveState.k_Curve, MinMaxCurveState.k_TwoScalars, MinMaxCurveState.k_TwoCurves }; bool[] flagArray = new bool[4] { (minMaxCurves[0].m_AllowConstant ? 1 : 0) != 0, (minMaxCurves[0].m_AllowCurves ? 1 : 0) != 0, (minMaxCurves[0].m_AllowRandom ? 1 : 0) != 0, (!minMaxCurves[0].m_AllowRandom ? 0 : (minMaxCurves[0].m_AllowCurves ? 1 : 0)) != 0 }; GenericMenu genericMenu = new GenericMenu(); for (int index = 0; index < guiContentArray.Length; ++index) { if (flagArray[index]) { genericMenu.AddItem(guiContentArray[index], minMaxCurves[0].state == minMaxCurveStateArray[index], new GenericMenu.MenuFunction2(ModuleUI.SelectMinMaxCurveStateCallback), (object)new ModuleUI.CurveStateCallbackData(minMaxCurveStateArray[index], minMaxCurves)); } } genericMenu.DropDown(rect); Event.current.Use(); }
private void InitSingleScalar(MinMaxCurveState oldState) { if (oldState == MinMaxCurveState.k_Curve || oldState == MinMaxCurveState.k_TwoCurves || oldState == MinMaxCurveState.k_TwoScalars) { float maxKeyValue = this.GetMaxKeyValue(this.maxCurve.animationCurveValue.keys); this.scalar.floatValue *= maxKeyValue; } this.SetCurveConstant(this.maxCurve, 1f); }
private void InitSingleCurve(MinMaxCurveState oldState) { switch (oldState) { case MinMaxCurveState.k_Scalar: this.SetCurveConstant(this.maxCurve, this.GetNormalizedValueFromScalar()); break; } this.SetCurveRequirements(); }
public static void GUIMinMaxCurve(GUIContent label, SerializedMinMaxCurve mmCurve) { Rect controlRect = GetControlRect(13); Rect popupRect = GetPopupRect(controlRect); controlRect = SubtractPopupWidth(controlRect); Rect position = PrefixLabel(controlRect, label); MinMaxCurveState state = mmCurve.state; switch (state) { case MinMaxCurveState.k_Scalar: { float a = FloatDraggable(controlRect, mmCurve.scalar, mmCurve.m_RemapValue, EditorGUIUtility.labelWidth); if (!mmCurve.signedRange) { mmCurve.scalar.floatValue = Mathf.Max(a, 0f); } break; } case MinMaxCurveState.k_TwoScalars: { Rect rect4 = position; rect4.width = (position.width - 20f) * 0.5f; float minConstant = mmCurve.minConstant; float maxConstant = mmCurve.maxConstant; Rect rect = rect4; rect.xMin -= 20f; EditorGUI.BeginChangeCheck(); minConstant = FloatDraggable(rect, minConstant, mmCurve.m_RemapValue, 20f, "g5"); if (EditorGUI.EndChangeCheck()) { mmCurve.minConstant = minConstant; } rect.x += rect4.width + 20f; EditorGUI.BeginChangeCheck(); maxConstant = FloatDraggable(rect, maxConstant, mmCurve.m_RemapValue, 20f, "g5"); if (EditorGUI.EndChangeCheck()) { mmCurve.maxConstant = maxConstant; } break; } default: { Rect ranges = !mmCurve.signedRange ? kUnsignedRange : kSignedRange; SerializedProperty minCurve = (state != MinMaxCurveState.k_TwoCurves) ? null : mmCurve.minCurve; GUICurveField(position, mmCurve.maxCurve, minCurve, GetColor(mmCurve), ranges, new CurveFieldMouseDownCallback(mmCurve.OnCurveAreaMouseDown)); break; } } GUIMMCurveStateList(popupRect, mmCurve); }
public void SetMinMaxState(MinMaxCurveState newState, bool addToCurveEditor = true) { if (!this.stateHasMultipleDifferentValues) { if (newState == this.state) { return; } } MinMaxCurveState state = this.state; ParticleSystemCurveEditor particleSystemCurveEditor = this.m_Module.GetParticleSystemCurveEditor(); if (particleSystemCurveEditor.IsAdded(this.GetMinCurve(), this.maxCurve)) { particleSystemCurveEditor.RemoveCurve(this.GetMinCurve(), this.maxCurve); } switch (newState) { case MinMaxCurveState.k_Scalar: this.InitSingleScalar(state); break; case MinMaxCurveState.k_Curve: this.InitSingleCurve(state); break; case MinMaxCurveState.k_TwoCurves: this.InitDoubleCurves(state); break; case MinMaxCurveState.k_TwoScalars: this.InitDoubleScalars(state); break; } this.minMaxState.intValue = (int)newState; if (addToCurveEditor) { switch (newState) { case MinMaxCurveState.k_Scalar: case MinMaxCurveState.k_TwoScalars: break; case MinMaxCurveState.k_Curve: case MinMaxCurveState.k_TwoCurves: particleSystemCurveEditor.AddCurve(this.CreateCurveData(particleSystemCurveEditor.GetAvailableColor())); break; default: Debug.LogError("Unhandled enum value"); break; } } AnimationCurvePreviewCache.ClearCache(); }
public override void OnInspectorGUI(InitialModuleUI initial) { MinMaxCurveState state = this.m_X.state; base.GUITripleMinMaxCurve(GUIContent.none, ForceModuleUI.s_Texts.x, this.m_X, ForceModuleUI.s_Texts.y, this.m_Y, ForceModuleUI.s_Texts.z, this.m_Z, this.m_RandomizePerFrame, new GUILayoutOption[0]); ModuleUI.GUIBoolAsPopup(ForceModuleUI.s_Texts.space, this.m_InWorldSpace, ForceModuleUI.s_Texts.spaces, new GUILayoutOption[0]); using (new EditorGUI.DisabledScope(state != MinMaxCurveState.k_TwoScalars && state != MinMaxCurveState.k_TwoCurves)) { ModuleUI.GUIToggle(ForceModuleUI.s_Texts.randomizePerFrame, this.m_RandomizePerFrame, new GUILayoutOption[0]); } }
private void InitSingleScalar(MinMaxCurveState oldState) { switch (oldState) { case MinMaxCurveState.k_Curve: case MinMaxCurveState.k_TwoCurves: case MinMaxCurveState.k_TwoScalars: this.scalar.floatValue *= this.GetMaxKeyValue(this.maxCurve.animationCurveValue.keys); break; } this.SetCurveConstant(this.maxCurve, 1f); }
override public void OnInspectorGUI(InitialModuleUI initial) { MinMaxCurveState state = m_X.state; GUITripleMinMaxCurve(GUIContent.none, s_Texts.x, m_X, s_Texts.y, m_Y, s_Texts.z, m_Z, m_RandomizePerFrame); GUIBoolAsPopup(s_Texts.space, m_InWorldSpace, s_Texts.spaces); using (new EditorGUI.DisabledScope((state != MinMaxCurveState.k_TwoScalars) && (state != MinMaxCurveState.k_TwoCurves))) { GUIToggle(s_Texts.randomizePerFrame, m_RandomizePerFrame); } }
private void InitSingleCurve(MinMaxCurveState oldState) { if (oldState != MinMaxCurveState.k_Scalar) { if (oldState != MinMaxCurveState.k_TwoScalars && oldState != MinMaxCurveState.k_TwoCurves) { } } else { this.SetCurveConstant(this.maxCurve, this.GetNormalizedValueFromScalar()); } this.SetCurveRequirements(); }
public static void GUIMinMaxCurve(GUIContent label, SerializedMinMaxCurve mmCurve) { Rect rect = ModuleUI.GetControlRect(13); Rect popupRect = ModuleUI.GetPopupRect(rect); rect = ModuleUI.SubtractPopupWidth(rect); Rect rect2 = ModuleUI.PrefixLabel(rect, label); MinMaxCurveState state = mmCurve.state; if (state == MinMaxCurveState.k_Scalar) { float a = ModuleUI.FloatDraggable(rect, mmCurve.scalar, mmCurve.m_RemapValue, EditorGUIUtility.labelWidth); if (!mmCurve.signedRange) { mmCurve.scalar.floatValue = Mathf.Max(a, 0f); } } else { if (state == MinMaxCurveState.k_TwoScalars) { Rect rect3 = rect2; rect3.width = (rect2.width - 20f) * 0.5f; float num = mmCurve.minConstant; float num2 = mmCurve.maxConstant; Rect rect4 = rect3; rect4.xMin -= 20f; EditorGUI.BeginChangeCheck(); num = ModuleUI.FloatDraggable(rect4, num, mmCurve.m_RemapValue, 20f, "g5"); if (EditorGUI.EndChangeCheck()) { mmCurve.minConstant = num; } rect4.x += rect3.width + 20f; EditorGUI.BeginChangeCheck(); num2 = ModuleUI.FloatDraggable(rect4, num2, mmCurve.m_RemapValue, 20f, "g5"); if (EditorGUI.EndChangeCheck()) { mmCurve.maxConstant = num2; } } else { Rect ranges = (!mmCurve.signedRange) ? ModuleUI.kUnsignedRange : ModuleUI.kSignedRange; SerializedProperty minCurve = (state != MinMaxCurveState.k_TwoCurves) ? null : mmCurve.minCurve; ModuleUI.GUICurveField(rect2, mmCurve.maxCurve, minCurve, ModuleUI.GetColor(mmCurve), ranges, new ModuleUI.CurveFieldMouseDownCallback(mmCurve.OnCurveAreaMouseDown)); } } ModuleUI.GUIMMCurveStateList(popupRect, mmCurve); }
public override void OnInspectorGUI(ParticleSystem s) { if (ForceModuleUI.s_Texts == null) { ForceModuleUI.s_Texts = new ForceModuleUI.Texts(); } MinMaxCurveState state = this.m_X.state; this.GUITripleMinMaxCurve(GUIContent.none, ForceModuleUI.s_Texts.x, this.m_X, ForceModuleUI.s_Texts.y, this.m_Y, ForceModuleUI.s_Texts.z, this.m_Z, this.m_RandomizePerFrame); ModuleUI.GUIBoolAsPopup(ForceModuleUI.s_Texts.space, this.m_InWorldSpace, ForceModuleUI.s_Texts.spaces); EditorGUI.BeginDisabledGroup(state != MinMaxCurveState.k_TwoScalars && state != MinMaxCurveState.k_TwoCurves); ModuleUI.GUIToggle(ForceModuleUI.s_Texts.randomizePerFrame, this.m_RandomizePerFrame); EditorGUI.EndDisabledGroup(); }
public void SetMinMaxState(MinMaxCurveState newState, bool addToCurveEditor) { if (newState == state) { return; } MinMaxCurveState oldState = state; ParticleSystemCurveEditor sce = m_Module.GetParticleSystemCurveEditor(); if (sce.IsAdded(GetMinCurve(), maxCurve)) { sce.RemoveCurve(GetMinCurve(), maxCurve); } switch (newState) { case MinMaxCurveState.k_Curve: SetCurveRequirements(); break; case MinMaxCurveState.k_TwoCurves: SetCurveRequirements(); break; } // Assign state AFTER matching data to new state AND removing curve from curveEditor since it uses current 'state' minMaxState.intValue = (int)newState; if (addToCurveEditor) { // Add curve to CurveEditor if needed // Keep added to the editor if it was added before switch (newState) { case MinMaxCurveState.k_TwoCurves: case MinMaxCurveState.k_Curve: sce.AddCurve(CreateCurveData(sce.GetAvailableColor())); break; case MinMaxCurveState.k_Scalar: case MinMaxCurveState.k_TwoScalars: // Scalar do not add anything to the curve editor break; default: Debug.LogError("Unhandled enum value"); break; } } // Ensure we draw new icons for properties UnityEditorInternal.AnimationCurvePreviewCache.ClearCache(); }
private void InitDoubleCurves(MinMaxCurveState oldState) { if (oldState != MinMaxCurveState.k_Scalar) { if ((oldState != MinMaxCurveState.k_TwoScalars) && (oldState == MinMaxCurveState.k_Curve)) { } } else { this.SetCurveConstant(this.maxCurve, this.GetNormalizedValueFromScalar()); } this.SetCurveRequirements(); }
public static void GUIMinMaxCurve(GUIContent label, SerializedMinMaxCurve mmCurve) { Rect controlRect = ModuleUI.GetControlRect(13); Rect popupRect = ModuleUI.GetPopupRect(controlRect); Rect rect1 = ModuleUI.SubtractPopupWidth(controlRect); Rect position = ModuleUI.PrefixLabel(rect1, label); MinMaxCurveState state = mmCurve.state; switch (state) { case MinMaxCurveState.k_Scalar: float a = ModuleUI.FloatDraggable(rect1, mmCurve.scalar, mmCurve.m_RemapValue, EditorGUIUtility.labelWidth); if (!mmCurve.signedRange) { mmCurve.scalar.floatValue = Mathf.Max(a, 0.0f); break; } break; case MinMaxCurveState.k_TwoScalars: Rect rect2 = position; rect2.width = (float)(((double)position.width - 20.0) * 0.5); float minConstant = mmCurve.minConstant; float maxConstant = mmCurve.maxConstant; Rect rect3 = rect2; rect3.xMin -= 20f; EditorGUI.BeginChangeCheck(); float num1 = ModuleUI.FloatDraggable(rect3, minConstant, mmCurve.m_RemapValue, 20f, "g5"); if (EditorGUI.EndChangeCheck()) { mmCurve.minConstant = num1; } rect3.x += rect2.width + 20f; EditorGUI.BeginChangeCheck(); float num2 = ModuleUI.FloatDraggable(rect3, maxConstant, mmCurve.m_RemapValue, 20f, "g5"); if (EditorGUI.EndChangeCheck()) { mmCurve.maxConstant = num2; break; } break; default: Rect ranges = !mmCurve.signedRange ? ModuleUI.kUnsignedRange : ModuleUI.kSignedRange; SerializedProperty minCurve = state != MinMaxCurveState.k_TwoCurves ? (SerializedProperty)null : mmCurve.minCurve; ModuleUI.GUICurveField(position, mmCurve.maxCurve, minCurve, ModuleUI.GetColor(mmCurve), ranges, new ModuleUI.CurveFieldMouseDownCallback(mmCurve.OnCurveAreaMouseDown)); break; } ModuleUI.GUIMMCurveStateList(popupRect, mmCurve); }
private void SetMinMaxState(MinMaxCurveState newState) { if (newState == this.state) { return; } MinMaxCurveState state = this.state; ParticleSystemCurveEditor systemCurveEditor = this.m_Module.GetParticleSystemCurveEditor(); if (systemCurveEditor.IsAdded(this.GetMinCurve(), this.maxCurve)) { systemCurveEditor.RemoveCurve(this.GetMinCurve(), this.maxCurve); } switch (newState) { case MinMaxCurveState.k_Scalar: this.InitSingleScalar(state); break; case MinMaxCurveState.k_Curve: this.InitSingleCurve(state); break; case MinMaxCurveState.k_TwoCurves: this.InitDoubleCurves(state); break; case MinMaxCurveState.k_TwoScalars: this.InitDoubleScalars(state); break; } this.minMaxState.intValue = (int)newState; switch (newState) { case MinMaxCurveState.k_Scalar: case MinMaxCurveState.k_TwoScalars: AnimationCurvePreviewCache.ClearCache(); break; case MinMaxCurveState.k_Curve: case MinMaxCurveState.k_TwoCurves: systemCurveEditor.AddCurve(this.CreateCurveData(systemCurveEditor.GetAvailableColor())); goto case MinMaxCurveState.k_Scalar; default: Debug.LogError((object)"Unhandled enum value"); goto case MinMaxCurveState.k_Scalar; } }
public override void OnInspectorGUI(ParticleSystem s) { if (s_Texts == null) { s_Texts = new Texts(); } MinMaxCurveState state = this.m_X.state; base.GUITripleMinMaxCurve(GUIContent.none, s_Texts.x, this.m_X, s_Texts.y, this.m_Y, s_Texts.z, this.m_Z, this.m_RandomizePerFrame, new GUILayoutOption[0]); ModuleUI.GUIBoolAsPopup(s_Texts.space, this.m_InWorldSpace, s_Texts.spaces, new GUILayoutOption[0]); using (new EditorGUI.DisabledScope((state != MinMaxCurveState.k_TwoScalars) && (state != MinMaxCurveState.k_TwoCurves))) { ModuleUI.GUIToggle(s_Texts.randomizePerFrame, this.m_RandomizePerFrame, new GUILayoutOption[0]); } }
public void SetMinMaxState(MinMaxCurveState newState, bool addToCurveEditor) { if (this.stateHasMultipleDifferentValues) { Debug.LogError("SetMinMaxState is not allowed with multiple different values"); } else if (newState != this.state) { MinMaxCurveState state = this.state; ParticleSystemCurveEditor particleSystemCurveEditor = this.m_Module.GetParticleSystemCurveEditor(); if (particleSystemCurveEditor.IsAdded(this.GetMinCurve(), this.maxCurve)) { particleSystemCurveEditor.RemoveCurve(this.GetMinCurve(), this.maxCurve); } if (newState != MinMaxCurveState.k_Curve) { if (newState == MinMaxCurveState.k_TwoCurves) { this.SetCurveRequirements(); } } else { this.SetCurveRequirements(); } this.minMaxState.intValue = (int)newState; if (addToCurveEditor) { switch (newState) { case MinMaxCurveState.k_Scalar: case MinMaxCurveState.k_TwoScalars: break; case MinMaxCurveState.k_Curve: case MinMaxCurveState.k_TwoCurves: particleSystemCurveEditor.AddCurve(this.CreateCurveData(particleSystemCurveEditor.GetAvailableColor())); break; default: Debug.LogError("Unhandled enum value"); break; } } AnimationCurvePreviewCache.ClearCache(); } }
public static void GUIMMCurveStateList(Rect rect, SerializedMinMaxCurve[] minMaxCurves) { if (EditorGUI.ButtonMouseDown(rect, GUIContent.none, FocusType.Passive, ParticleSystemStyles.Get().minMaxCurveStateDropDown)) { if (minMaxCurves.Length != 0) { GUIContent[] array = new GUIContent[] { new GUIContent("Constant"), new GUIContent("Curve"), new GUIContent("Random Between Two Constants"), new GUIContent("Random Between Two Curves") }; MinMaxCurveState[] array2 = new MinMaxCurveState[] { MinMaxCurveState.k_Scalar, MinMaxCurveState.k_Curve, MinMaxCurveState.k_TwoScalars, MinMaxCurveState.k_TwoCurves }; bool[] array3 = new bool[] { minMaxCurves[0].m_AllowConstant, minMaxCurves[0].m_AllowCurves, minMaxCurves[0].m_AllowRandom, minMaxCurves[0].m_AllowRandom && minMaxCurves[0].m_AllowCurves }; GenericMenu genericMenu = new GenericMenu(); for (int i = 0; i < array.Length; i++) { if (array3[i]) { GenericMenu arg_10C_0 = genericMenu; GUIContent arg_10C_1 = array[i]; bool arg_10C_2 = minMaxCurves[0].state == array2[i]; if (ModuleUI.< > f__mg$cache0 == null) { ModuleUI.< > f__mg$cache0 = new GenericMenu.MenuFunction2(ModuleUI.SelectMinMaxCurveStateCallback); } arg_10C_0.AddItem(arg_10C_1, arg_10C_2, ModuleUI.< > f__mg$cache0, new ModuleUI.CurveStateCallbackData(array2[i], minMaxCurves)); } } genericMenu.DropDown(rect); Event.current.Use(); } } }
public override void OnInspectorGUI(ParticleSystem s) { if (SizeByVelocityModuleUI.s_Texts == null) { SizeByVelocityModuleUI.s_Texts = new SizeByVelocityModuleUI.Texts(); } EditorGUI.BeginChangeCheck(); bool flag = ModuleUI.GUIToggle(SizeByVelocityModuleUI.s_Texts.separateAxes, this.m_SeparateAxes, new GUILayoutOption[0]); if (EditorGUI.EndChangeCheck()) { if (flag) { this.m_X.RemoveCurveFromEditor(); } else { this.m_X.RemoveCurveFromEditor(); this.m_Y.RemoveCurveFromEditor(); this.m_Z.RemoveCurveFromEditor(); } } SerializedMinMaxCurve arg_9C_0 = this.m_Z; MinMaxCurveState state = this.m_X.state; this.m_Y.state = state; arg_9C_0.state = state; MinMaxCurveState state2 = this.m_Z.state; if (flag) { this.m_X.m_DisplayName = SizeByVelocityModuleUI.s_Texts.x; base.GUITripleMinMaxCurve(GUIContent.none, SizeByVelocityModuleUI.s_Texts.x, this.m_X, SizeByVelocityModuleUI.s_Texts.y, this.m_Y, SizeByVelocityModuleUI.s_Texts.z, this.m_Z, null, new GUILayoutOption[0]); } else { this.m_X.m_DisplayName = SizeByVelocityModuleUI.s_Texts.size; ModuleUI.GUIMinMaxCurve(SizeByVelocityModuleUI.s_Texts.size, this.m_X, new GUILayoutOption[0]); } using (new EditorGUI.DisabledScope(state2 == MinMaxCurveState.k_Scalar || state2 == MinMaxCurveState.k_TwoScalars)) { ModuleUI.GUIMinMaxRange(SizeByVelocityModuleUI.s_Texts.velocityRange, this.m_Range, new GUILayoutOption[0]); } }
public override void OnInspectorGUI(ParticleSystem s) { if (s_Texts == null) { s_Texts = new Texts(); } EditorGUI.BeginChangeCheck(); bool flag = ModuleUI.GUIToggle(s_Texts.separateAxes, this.m_SeparateAxes, new GUILayoutOption[0]); if (EditorGUI.EndChangeCheck()) { if (flag) { this.m_Z.RemoveCurveFromEditor(); } else { this.m_X.RemoveCurveFromEditor(); this.m_Y.RemoveCurveFromEditor(); this.m_Z.RemoveCurveFromEditor(); } } MinMaxCurveState state = this.m_Z.state; this.m_Y.state = state; this.m_X.state = state; MinMaxCurveState state2 = this.m_Z.state; if (flag) { this.m_Z.m_DisplayName = s_Texts.z; base.GUITripleMinMaxCurve(GUIContent.none, s_Texts.x, this.m_X, s_Texts.y, this.m_Y, s_Texts.z, this.m_Z, null, new GUILayoutOption[0]); } else { this.m_Z.m_DisplayName = s_Texts.rotation; ModuleUI.GUIMinMaxCurve(s_Texts.rotation, this.m_Z, new GUILayoutOption[0]); } using (new EditorGUI.DisabledScope((state2 == MinMaxCurveState.k_Scalar) || (state2 == MinMaxCurveState.k_TwoScalars))) { ModuleUI.GUIMinMaxRange(s_Texts.velocityRange, this.m_Range, new GUILayoutOption[0]); } }
private void InitDoubleScalars(MinMaxCurveState oldState) { this.minConstant = this.GetAverageKeyValue(this.minCurve.animationCurveValue.keys) * this.scalar.floatValue; switch (oldState) { case MinMaxCurveState.k_Scalar: this.maxConstant = this.scalar.floatValue; break; case MinMaxCurveState.k_Curve: case MinMaxCurveState.k_TwoCurves: this.maxConstant = this.GetAverageKeyValue(this.maxCurve.animationCurveValue.keys) * this.scalar.floatValue; break; default: Debug.LogError("Enum not handled!"); break; } this.SetCurveRequirements(); }
override public void OnInspectorGUI(InitialModuleUI initial) { EditorGUI.BeginChangeCheck(); bool separateAxes = GUIToggle(s_Texts.separateAxes, m_SeparateAxes); if (EditorGUI.EndChangeCheck()) { // Remove old curves from curve editor if (!separateAxes) { m_Y.RemoveCurveFromEditor(); m_Z.RemoveCurveFromEditor(); } } // Keep states in sync if (!m_X.stateHasMultipleDifferentValues) { m_Z.SetMinMaxState(m_X.state, separateAxes); m_Y.SetMinMaxState(m_X.state, separateAxes); } MinMaxCurveState state = m_Z.state; if (separateAxes) { m_X.m_DisplayName = s_Texts.x; GUITripleMinMaxCurve(GUIContent.none, s_Texts.x, m_X, s_Texts.y, m_Y, s_Texts.z, m_Z, null); } else { m_X.m_DisplayName = s_Texts.size; GUIMinMaxCurve(s_Texts.size, m_X); } using (new EditorGUI.DisabledScope((state == MinMaxCurveState.k_Scalar) || (state == MinMaxCurveState.k_TwoScalars))) { GUIMinMaxRange(s_Texts.velocityRange, m_Range); } }
public override void OnInspectorGUI(ParticleSystem s) { if (RotationModuleUI.s_Texts == null) { RotationModuleUI.s_Texts = new RotationModuleUI.Texts(); } EditorGUI.BeginChangeCheck(); bool flag = ModuleUI.GUIToggle(RotationModuleUI.s_Texts.separateAxes, this.m_SeparateAxes, new GUILayoutOption[0]); if (EditorGUI.EndChangeCheck()) { if (flag) { this.m_Z.RemoveCurveFromEditor(); } else { this.m_X.RemoveCurveFromEditor(); this.m_Y.RemoveCurveFromEditor(); this.m_Z.RemoveCurveFromEditor(); } } SerializedMinMaxCurve arg_9C_0 = this.m_X; MinMaxCurveState state = this.m_Z.state; this.m_Y.state = state; arg_9C_0.state = state; if (flag) { this.m_Z.m_DisplayName = RotationModuleUI.s_Texts.z; base.GUITripleMinMaxCurve(GUIContent.none, RotationModuleUI.s_Texts.x, this.m_X, RotationModuleUI.s_Texts.y, this.m_Y, RotationModuleUI.s_Texts.z, this.m_Z, null, new GUILayoutOption[0]); } else { this.m_Z.m_DisplayName = RotationModuleUI.s_Texts.rotation; ModuleUI.GUIMinMaxCurve(RotationModuleUI.s_Texts.rotation, this.m_Z, new GUILayoutOption[0]); } }
public override void OnInspectorGUI(ParticleSystem s) { if (SizeModuleUI.s_Texts == null) { SizeModuleUI.s_Texts = new SizeModuleUI.Texts(); } EditorGUI.BeginChangeCheck(); bool flag = ModuleUI.GUIToggle(SizeModuleUI.s_Texts.separateAxes, this.m_SeparateAxes); if (EditorGUI.EndChangeCheck()) { if (flag) { this.m_X.RemoveCurveFromEditor(); } else { this.m_X.RemoveCurveFromEditor(); this.m_Y.RemoveCurveFromEditor(); this.m_Z.RemoveCurveFromEditor(); } } SerializedMinMaxCurve arg_8F_0 = this.m_Z; MinMaxCurveState state = this.m_X.state; this.m_Y.state = state; arg_8F_0.state = state; if (flag) { this.m_X.m_DisplayName = SizeModuleUI.s_Texts.x; base.GUITripleMinMaxCurve(GUIContent.none, SizeModuleUI.s_Texts.x, this.m_X, SizeModuleUI.s_Texts.y, this.m_Y, SizeModuleUI.s_Texts.z, this.m_Z, null); } else { this.m_X.m_DisplayName = SizeModuleUI.s_Texts.size; ModuleUI.GUIMinMaxCurve(SizeModuleUI.s_Texts.size, this.m_X); } }
public static void GUIMMCurveStateList(Rect rect, SerializedMinMaxCurve[] minMaxCurves) { if (EditorGUI.ButtonMouseDown(rect, GUIContent.none, FocusType.Passive, ParticleSystemStyles.Get().minMaxCurveStateDropDown) && (minMaxCurves.Length != 0)) { GUIContent[] contentArray = new GUIContent[] { new GUIContent("Constant"), new GUIContent("Curve"), new GUIContent("Random Between Two Constants"), new GUIContent("Random Between Two Curves") }; MinMaxCurveState[] stateArray1 = new MinMaxCurveState[4]; stateArray1[1] = MinMaxCurveState.k_Curve; stateArray1[2] = MinMaxCurveState.k_TwoScalars; stateArray1[3] = MinMaxCurveState.k_TwoCurves; MinMaxCurveState[] stateArray = stateArray1; bool[] flagArray = new bool[] { minMaxCurves[0].m_AllowConstant, true, minMaxCurves[0].m_AllowRandom, minMaxCurves[0].m_AllowRandom }; GenericMenu menu = new GenericMenu(); for (int i = 0; i < contentArray.Length; i++) { if (flagArray[i]) { menu.AddItem(contentArray[i], minMaxCurves[0].state == stateArray[i], new GenericMenu.MenuFunction2(ModuleUI.SelectMinMaxCurveStateCallback), new CurveStateCallbackData(stateArray[i], minMaxCurves)); } } menu.DropDown(rect); Event.current.Use(); } }
public override void OnInspectorGUI(ParticleSystem s) { if (s_Texts == null) { s_Texts = new Texts(); } EditorGUI.BeginChangeCheck(); bool flag = ModuleUI.GUIToggle(s_Texts.separateAxes, this.m_SeparateAxes, new GUILayoutOption[0]); if (EditorGUI.EndChangeCheck()) { if (flag) { this.m_X.RemoveCurveFromEditor(); } else { this.m_X.RemoveCurveFromEditor(); this.m_Y.RemoveCurveFromEditor(); this.m_Z.RemoveCurveFromEditor(); } } MinMaxCurveState state = this.m_X.state; this.m_Y.state = state; this.m_Z.state = state; if (flag) { this.m_X.m_DisplayName = s_Texts.x; base.GUITripleMinMaxCurve(GUIContent.none, s_Texts.x, this.m_X, s_Texts.y, this.m_Y, s_Texts.z, this.m_Z, null, new GUILayoutOption[0]); } else { this.m_X.m_DisplayName = s_Texts.size; ModuleUI.GUIMinMaxCurve(s_Texts.size, this.m_X, new GUILayoutOption[0]); } }
public CurveStateCallbackData(MinMaxCurveState state, SerializedMinMaxCurve[] curves) { this.minMaxCurves = curves; this.selectedState = state; }
public static void GUIMMCurveStateList(Rect rect, SerializedMinMaxCurve[] minMaxCurves) { if (!EditorGUI.ButtonMouseDown(rect, GUIContent.none, FocusType.Passive, ParticleSystemStyles.Get().minMaxCurveStateDropDown) || minMaxCurves.Length == 0) return; GUIContent[] guiContentArray = new GUIContent[4]{ new GUIContent("Constant"), new GUIContent("Curve"), new GUIContent("Random Between Two Constants"), new GUIContent("Random Between Two Curves") }; MinMaxCurveState[] minMaxCurveStateArray = new MinMaxCurveState[4]{ MinMaxCurveState.k_Scalar, MinMaxCurveState.k_Curve, MinMaxCurveState.k_TwoScalars, MinMaxCurveState.k_TwoCurves }; bool[] flagArray = new bool[4]{ (minMaxCurves[0].m_AllowConstant ? 1 : 0) != 0, (minMaxCurves[0].m_AllowCurves ? 1 : 0) != 0, (minMaxCurves[0].m_AllowRandom ? 1 : 0) != 0, (!minMaxCurves[0].m_AllowRandom ? 0 : (minMaxCurves[0].m_AllowCurves ? 1 : 0)) != 0 }; GenericMenu genericMenu = new GenericMenu(); for (int index = 0; index < guiContentArray.Length; ++index) { if (flagArray[index]) genericMenu.AddItem(guiContentArray[index], minMaxCurves[0].state == minMaxCurveStateArray[index], new GenericMenu.MenuFunction2(ModuleUI.SelectMinMaxCurveStateCallback), (object) new ModuleUI.CurveStateCallbackData(minMaxCurveStateArray[index], minMaxCurves)); } genericMenu.DropDown(rect); Event.current.Use(); }
public void GUITripleMinMaxCurve(GUIContent label, GUIContent x, SerializedMinMaxCurve xCurve, GUIContent y, SerializedMinMaxCurve yCurve, GUIContent z, SerializedMinMaxCurve zCurve, SerializedProperty randomizePerFrame) { MinMaxCurveState state = xCurve.state; bool flag = label != GUIContent.none; int num = (!flag) ? 1 : 2; if (state == MinMaxCurveState.k_TwoScalars) { num++; } Rect rect = ModuleUI.GetControlRect(13 * num); Rect popupRect = ModuleUI.GetPopupRect(rect); rect = ModuleUI.SubtractPopupWidth(rect); Rect rect2 = rect; float num2 = (rect.width - 8f) / 3f; if (num > 1) { rect2.height = 13f; } if (flag) { ModuleUI.PrefixLabel(rect, label); rect2.y += rect2.height; } rect2.width = num2; GUIContent[] array = new GUIContent[] { x, y, z }; SerializedMinMaxCurve[] array2 = new SerializedMinMaxCurve[] { xCurve, yCurve, zCurve }; if (state == MinMaxCurveState.k_Scalar) { for (int i = 0; i < array2.Length; i++) { ModuleUI.Label(rect2, array[i]); float a = ModuleUI.FloatDraggable(rect2, array2[i].scalar, array2[i].m_RemapValue, 10f); if (!array2[i].signedRange) { array2[i].scalar.floatValue = Mathf.Max(a, 0f); } rect2.x += num2 + 4f; } } else if (state == MinMaxCurveState.k_TwoScalars) { for (int j = 0; j < array2.Length; j++) { ModuleUI.Label(rect2, array[j]); float num3 = array2[j].minConstant; float num4 = array2[j].maxConstant; EditorGUI.BeginChangeCheck(); num4 = ModuleUI.FloatDraggable(rect2, num4, array2[j].m_RemapValue, 10f, "g5"); if (EditorGUI.EndChangeCheck()) { array2[j].maxConstant = num4; } rect2.y += 13f; EditorGUI.BeginChangeCheck(); num3 = ModuleUI.FloatDraggable(rect2, num3, array2[j].m_RemapValue, 10f, "g5"); if (EditorGUI.EndChangeCheck()) { array2[j].minConstant = num3; } rect2.x += num2 + 4f; rect2.y -= 13f; } } else { rect2.width = num2; Rect ranges = (!xCurve.signedRange) ? ModuleUI.kUnsignedRange : ModuleUI.kSignedRange; for (int k = 0; k < array2.Length; k++) { ModuleUI.Label(rect2, array[k]); Rect position = rect2; position.xMin += 10f; SerializedProperty minCurve = (state != MinMaxCurveState.k_TwoCurves) ? null : array2[k].minCurve; ModuleUI.GUICurveField(position, array2[k].maxCurve, minCurve, ModuleUI.GetColor(array2[k]), ranges, new ModuleUI.CurveFieldMouseDownCallback(array2[k].OnCurveAreaMouseDown)); rect2.x += num2 + 4f; } } ModuleUI.GUIMMCurveStateList(popupRect, array2); }
public CurveStateCallbackData(MinMaxCurveState state, SerializedMinMaxCurve[] curves) { this.minMaxCurves = curves; this.selectedState = state; }
public static void GUIMMCurveStateList(Rect rect, SerializedMinMaxCurve[] minMaxCurves) { if (EditorGUI.ButtonMouseDown(rect, GUIContent.none, FocusType.Passive, ParticleSystemStyles.Get().minMaxCurveStateDropDown)) { if (minMaxCurves.Length == 0) { return; } GUIContent[] array = new GUIContent[] { new GUIContent("Constant"), new GUIContent("Curve"), new GUIContent("Random Between Two Constants"), new GUIContent("Random Between Two Curves") }; MinMaxCurveState[] array2 = new MinMaxCurveState[] { MinMaxCurveState.k_Scalar, MinMaxCurveState.k_Curve, MinMaxCurveState.k_TwoScalars, MinMaxCurveState.k_TwoCurves }; bool[] array3 = new bool[] { minMaxCurves[0].m_AllowConstant, true, minMaxCurves[0].m_AllowRandom, minMaxCurves[0].m_AllowRandom }; GenericMenu genericMenu = new GenericMenu(); for (int i = 0; i < array.Length; i++) { if (array3[i]) { genericMenu.AddItem(array[i], minMaxCurves[0].state == array2[i], new GenericMenu.MenuFunction2(ModuleUI.SelectMinMaxCurveStateCallback), new ModuleUI.CurveStateCallbackData(array2[i], minMaxCurves)); } } genericMenu.DropDown(rect); Event.current.Use(); } }
public static void GUIMMCurveStateList(Rect rect, SerializedMinMaxCurve[] minMaxCurves) { if (EditorGUI.ButtonMouseDown(rect, GUIContent.none, FocusType.Passive, ParticleSystemStyles.Get().minMaxCurveStateDropDown) && (minMaxCurves.Length != 0)) { GUIContent[] contentArray = new GUIContent[] { new GUIContent("Constant"), new GUIContent("Curve"), new GUIContent("Random Between Two Constants"), new GUIContent("Random Between Two Curves") }; MinMaxCurveState[] stateArray1 = new MinMaxCurveState[4]; stateArray1[1] = MinMaxCurveState.k_Curve; stateArray1[2] = MinMaxCurveState.k_TwoScalars; stateArray1[3] = MinMaxCurveState.k_TwoCurves; MinMaxCurveState[] stateArray = stateArray1; bool[] flagArray = new bool[] { minMaxCurves[0].m_AllowConstant, true, minMaxCurves[0].m_AllowRandom, minMaxCurves[0].m_AllowRandom }; GenericMenu menu = new GenericMenu(); for (int i = 0; i < contentArray.Length; i++) { if (flagArray[i]) { menu.AddItem(contentArray[i], minMaxCurves[0].state == stateArray[i], new GenericMenu.MenuFunction2(ModuleUI.SelectMinMaxCurveStateCallback), new CurveStateCallbackData(stateArray[i], minMaxCurves)); } } menu.DropDown(rect); Event.current.Use(); } }
private void InitSingleScalar(MinMaxCurveState oldState) { if (((oldState == MinMaxCurveState.k_Curve) || (oldState == MinMaxCurveState.k_TwoCurves)) || (oldState == MinMaxCurveState.k_TwoScalars)) { float maxKeyValue = this.GetMaxKeyValue(this.maxCurve.animationCurveValue.keys); this.scalar.floatValue *= maxKeyValue; } this.SetCurveConstant(this.maxCurve, 1f); }
private void SetMinMaxState(MinMaxCurveState newState) { if (newState != this.state) { MinMaxCurveState oldState = this.state; ParticleSystemCurveEditor particleSystemCurveEditor = this.m_Module.GetParticleSystemCurveEditor(); if (particleSystemCurveEditor.IsAdded(this.GetMinCurve(), this.maxCurve)) { particleSystemCurveEditor.RemoveCurve(this.GetMinCurve(), this.maxCurve); } switch (newState) { case MinMaxCurveState.k_Scalar: this.InitSingleScalar(oldState); break; case MinMaxCurveState.k_Curve: this.InitSingleCurve(oldState); break; case MinMaxCurveState.k_TwoCurves: this.InitDoubleCurves(oldState); break; case MinMaxCurveState.k_TwoScalars: this.InitDoubleScalars(oldState); break; } this.minMaxState.intValue = (int) newState; switch (newState) { case MinMaxCurveState.k_Scalar: case MinMaxCurveState.k_TwoScalars: break; case MinMaxCurveState.k_Curve: case MinMaxCurveState.k_TwoCurves: particleSystemCurveEditor.AddCurve(this.CreateCurveData(particleSystemCurveEditor.GetAvailableColor())); break; default: Debug.LogError("Unhandled enum value"); break; } AnimationCurvePreviewCache.ClearCache(); } }
private void InitSingleCurve(MinMaxCurveState oldState) { if (oldState != MinMaxCurveState.k_Scalar) { if ((oldState == MinMaxCurveState.k_TwoScalars) || (oldState == MinMaxCurveState.k_TwoCurves)) { } } else { this.SetCurveConstant(this.maxCurve, this.GetNormalizedValueFromScalar()); } this.SetCurveRequirements(); }
private void InitDoubleScalars(MinMaxCurveState oldState) { this.minConstant = this.GetAverageKeyValue(this.minCurve.animationCurveValue.keys) * this.scalar.floatValue; switch (oldState) { case MinMaxCurveState.k_Scalar: this.maxConstant = this.scalar.floatValue; break; case MinMaxCurveState.k_Curve: case MinMaxCurveState.k_TwoCurves: this.maxConstant = this.GetAverageKeyValue(this.maxCurve.animationCurveValue.keys) * this.scalar.floatValue; break; default: Debug.LogError("Enum not handled!"); break; } this.SetCurveRequirements(); }
private void InitDoubleCurves(MinMaxCurveState oldState) { switch (oldState) { case MinMaxCurveState.k_Scalar: this.SetCurveConstant(this.maxCurve, this.GetNormalizedValueFromScalar()); break; } this.SetCurveRequirements(); }
private void InitSingleScalar(MinMaxCurveState oldState) { switch (oldState) { case MinMaxCurveState.k_Curve: case MinMaxCurveState.k_TwoCurves: case MinMaxCurveState.k_TwoScalars: this.scalar.floatValue *= this.GetMaxKeyValue(this.maxCurve.animationCurveValue.keys); break; } this.SetCurveConstant(this.maxCurve, 1f); }
private void SetMinMaxState(MinMaxCurveState newState) { if (newState == this.state) return; MinMaxCurveState state = this.state; ParticleSystemCurveEditor systemCurveEditor = this.m_Module.GetParticleSystemCurveEditor(); if (systemCurveEditor.IsAdded(this.GetMinCurve(), this.maxCurve)) systemCurveEditor.RemoveCurve(this.GetMinCurve(), this.maxCurve); switch (newState) { case MinMaxCurveState.k_Scalar: this.InitSingleScalar(state); break; case MinMaxCurveState.k_Curve: this.InitSingleCurve(state); break; case MinMaxCurveState.k_TwoCurves: this.InitDoubleCurves(state); break; case MinMaxCurveState.k_TwoScalars: this.InitDoubleScalars(state); break; } this.minMaxState.intValue = (int) newState; switch (newState) { case MinMaxCurveState.k_Scalar: case MinMaxCurveState.k_TwoScalars: AnimationCurvePreviewCache.ClearCache(); break; case MinMaxCurveState.k_Curve: case MinMaxCurveState.k_TwoCurves: systemCurveEditor.AddCurve(this.CreateCurveData(systemCurveEditor.GetAvailableColor())); goto case MinMaxCurveState.k_Scalar; default: Debug.LogError((object) "Unhandled enum value"); goto case MinMaxCurveState.k_Scalar; } }