Rename constantValue to fixedValue

adamgraham · adamgraham · commit b29d770b3967 · 2023-01-10T20:38:21.000-06:00
diff --git a/Editor/Events/EventReferencePropertyDrawer.cs b/Editor/Events/EventReferencePropertyDrawer.cs
@@ -27,18 +27,18 @@ public override void OnGUI(Rect position, SerializedProperty property, GUIConten
                 position = EditorGUI.PrefixLabel(position, label);
             }
 
+            int indent = EditorGUI.indentLevel;
+            EditorGUI.indentLevel = 0;
+
             Rect popupRect = new Rect(position);
             popupRect.width = popupStyle.fixedWidth + popupStyle.margin.right;
-            popupRect.height = EditorGUIUtility.singleLineHeight;
-            popupRect.y += (popupRect.height - popupStyle.fixedHeight) / 2f;
+            popupRect.height = popupStyle.fixedHeight;
+            popupRect.x += position.width - popupRect.width;
+            popupRect.y += (EditorGUIUtility.singleLineHeight - popupStyle.fixedHeight) / 2f;
             position.width -= popupRect.width;
-            popupRect.x += position.width;
 
             EditorGUI.BeginChangeCheck();
 
-            int indent = EditorGUI.indentLevel;
-            EditorGUI.indentLevel = 0;
-
             int result = EditorGUI.Popup(popupRect, useUnityEvent.boolValue ? 0 : 1, popupOptions, popupStyle);
             useUnityEvent.boolValue = result == 0;
 
diff --git a/Editor/Variables/ValueReferencePropertyDrawer.cs b/Editor/Variables/ValueReferencePropertyDrawer.cs
@@ -21,7 +21,7 @@ namespace Zigurous.Architecture.Editor
     [CustomPropertyDrawer(typeof(Vector4Reference), true)]
     public class ValueReferencePropertyDrawer : PropertyDrawer
     {
-        private readonly string[] popupOptions = { "Use Constant", "Use Variable" };
+        private readonly string[] popupOptions = { "Fixed Value", "Variable" };
         private static GUIStyle popupStyle;
 
         public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
@@ -32,29 +32,29 @@ public override void OnGUI(Rect position, SerializedProperty property, GUIConten
                 popupStyle.imagePosition = ImagePosition.ImageOnly;
             }
 
-            SerializedProperty useConstant = property.FindPropertyRelative("useConstant");
-            SerializedProperty constantValue = property.FindPropertyRelative("constantValue");
+            SerializedProperty useVariable = property.FindPropertyRelative("useVariable");
             SerializedProperty variable = property.FindPropertyRelative("variable");
+            SerializedProperty fixedValue = property.FindPropertyRelative("fixedValue");
 
             label = EditorGUI.BeginProperty(position, label, property);
             position = EditorGUI.PrefixLabel(position, label);
 
+            int indent = EditorGUI.indentLevel;
+            EditorGUI.indentLevel = 0;
+
             Rect popupRect = new Rect(position);
             popupRect.width = popupStyle.fixedWidth + popupStyle.margin.right;
-            popupRect.height = EditorGUIUtility.singleLineHeight;
-            popupRect.y += (popupRect.height - popupStyle.fixedHeight) / 2f;
+            popupRect.height = popupStyle.fixedHeight;
+            popupRect.x += position.width - popupRect.width;
+            popupRect.y += (EditorGUIUtility.singleLineHeight - popupStyle.fixedHeight) / 2f;
             position.width -= popupRect.width;
-            popupRect.x += position.width;
 
             EditorGUI.BeginChangeCheck();
 
-            int indent = EditorGUI.indentLevel;
-            EditorGUI.indentLevel = 0;
-
-            int result = EditorGUI.Popup(popupRect, useConstant.boolValue ? 0 : 1, popupOptions, popupStyle);
-            useConstant.boolValue = result == 0;
+            int result = EditorGUI.Popup(popupRect, useVariable.boolValue ? 1 : 0, popupOptions, popupStyle);
+            useVariable.boolValue = result == 1;
 
-            EditorGUI.PropertyField(position, useConstant.boolValue ? constantValue : variable, GUIContent.none, true);
+            EditorGUI.PropertyField(position, useVariable.boolValue ? variable : fixedValue, GUIContent.none, true);
 
             if (EditorGUI.EndChangeCheck()) {
                 property.serializedObject.ApplyModifiedProperties();
@@ -66,11 +66,11 @@ public override void OnGUI(Rect position, SerializedProperty property, GUIConten
 
         public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
         {
-            SerializedProperty useConstant = property.FindPropertyRelative("useConstant");
-            SerializedProperty constantValue = property.FindPropertyRelative("constantValue");
+            SerializedProperty useVariable = property.FindPropertyRelative("useVariable");
             SerializedProperty variable = property.FindPropertyRelative("variable");
+            SerializedProperty fixedValue = property.FindPropertyRelative("fixedValue");
 
-            return EditorGUI.GetPropertyHeight(useConstant.boolValue ? constantValue : variable, true);
+            return EditorGUI.GetPropertyHeight(useVariable.boolValue ? variable : fixedValue, true);
         }
 
     }
diff --git a/Runtime/Variables/BoolReference.cs b/Runtime/Variables/BoolReference.cs
@@ -12,9 +12,9 @@ public class BoolReference : ValueReference<bool, BoolVariable>
         public BoolReference() {}
 
         /// <summary>
-        /// Creates a new boolean reference with the constant value.
+        /// Creates a new boolean reference with the fixed value.
         /// </summary>
-        /// <param name="value">The constant value to set.</param>
+        /// <param name="value">The fixed value to set.</param>
         public BoolReference(bool value) : base(value) {}
 
         /// <summary>
diff --git a/Runtime/Variables/BoundsReference.cs b/Runtime/Variables/BoundsReference.cs
@@ -14,9 +14,9 @@ public class BoundsReference : ValueReference<Bounds, BoundsVariable>
         public BoundsReference() {}
 
         /// <summary>
-        /// Creates a new Bounds reference with the constant value.
+        /// Creates a new Bounds reference with the fixed value.
         /// </summary>
-        /// <param name="value">The constant value to set.</param>
+        /// <param name="value">The fixed value to set.</param>
         public BoundsReference(Bounds value) : base(value) {}
 
         /// <summary>
diff --git a/Runtime/Variables/DoubleReference.cs b/Runtime/Variables/DoubleReference.cs
@@ -12,9 +12,9 @@ public class DoubleReference : ValueReference<double, DoubleVariable>
         public DoubleReference() {}
 
         /// <summary>
-        /// Creates a new double reference with the constant value.
+        /// Creates a new double reference with the fixed value.
         /// </summary>
-        /// <param name="value">The constant value to set.</param>
+        /// <param name="value">The fixed value to set.</param>
         public DoubleReference(double value) : base(value) {}
 
         /// <summary>
diff --git a/Runtime/Variables/FloatReference.cs b/Runtime/Variables/FloatReference.cs
@@ -12,9 +12,9 @@ public class FloatReference : ValueReference<float, FloatVariable>
         public FloatReference() {}
 
         /// <summary>
-        /// Creates a new float reference with the constant value.
+        /// Creates a new float reference with the fixed value.
         /// </summary>
-        /// <param name="value">The constant value to set.</param>
+        /// <param name="value">The fixed value to set.</param>
         public FloatReference(float value) : base(value) {}
 
         /// <summary>
diff --git a/Runtime/Variables/IntReference.cs b/Runtime/Variables/IntReference.cs
@@ -12,9 +12,9 @@ public class IntReference : ValueReference<int, IntVariable>
         public IntReference() {}
 
         /// <summary>
-        /// Creates a new int reference with the constant value.
+        /// Creates a new int reference with the fixed value.
         /// </summary>
-        /// <param name="value">The constant value to set.</param>
+        /// <param name="value">The fixed value to set.</param>
         public IntReference(int value) : base(value) {}
 
         /// <summary>
diff --git a/Runtime/Variables/LongReference.cs b/Runtime/Variables/LongReference.cs
@@ -12,9 +12,9 @@ public class LongReference : ValueReference<long, LongVariable>
         public LongReference() {}
 
         /// <summary>
-        /// Creates a new long reference with the constant value.
+        /// Creates a new long reference with the fixed value.
         /// </summary>
-        /// <param name="value">The constant value to set.</param>
+        /// <param name="value">The fixed value to set.</param>
         public LongReference(long value) : base(value) {}
 
         /// <summary>
diff --git a/Runtime/Variables/QuaternionReference.cs b/Runtime/Variables/QuaternionReference.cs
@@ -14,9 +14,9 @@ public class QuaternionReference : ValueReference<Quaternion, QuaternionVariable
         public QuaternionReference() {}
 
         /// <summary>
-        /// Creates a new Quaternion reference with the constant value.
+        /// Creates a new Quaternion reference with the fixed value.
         /// </summary>
-        /// <param name="value">The constant value to set.</param>
+        /// <param name="value">The fixed value to set.</param>
         public QuaternionReference(Quaternion value) : base(value) {}
 
         /// <summary>
diff --git a/Runtime/Variables/RectReference.cs b/Runtime/Variables/RectReference.cs
@@ -14,9 +14,9 @@ public class RectReference : ValueReference<Rect, RectVariable>
         public RectReference() {}
 
         /// <summary>
-        /// Creates a new Rect reference with the constant value.
+        /// Creates a new Rect reference with the fixed value.
         /// </summary>
-        /// <param name="value">The constant value to set.</param>
+        /// <param name="value">The fixed value to set.</param>
         public RectReference(Rect value) : base(value) {}
 
         /// <summary>
diff --git a/Runtime/Variables/ShortReference.cs b/Runtime/Variables/ShortReference.cs
@@ -12,9 +12,9 @@ public class ShortReference : ValueReference<short, ShortVariable>
         public ShortReference() {}
 
         /// <summary>
-        /// Creates a new short reference with the constant value.
+        /// Creates a new short reference with the fixed value.
         /// </summary>
-        /// <param name="value">The constant value to set.</param>
+        /// <param name="value">The fixed value to set.</param>
         public ShortReference(short value) : base(value) {}
 
         /// <summary>
diff --git a/Runtime/Variables/StringReference.cs b/Runtime/Variables/StringReference.cs
@@ -12,9 +12,9 @@ public class StringReference : ValueReference<string, StringVariable>
         public StringReference() {}
 
         /// <summary>
-        /// Creates a new string reference with the constant value.
+        /// Creates a new string reference with the fixed value.
         /// </summary>
-        /// <param name="value">The constant value to set.</param>
+        /// <param name="value">The fixed value to set.</param>
         public StringReference(string value) : base(value) {}
 
         /// <summary>
diff --git a/Runtime/Variables/UIntReference.cs b/Runtime/Variables/UIntReference.cs
@@ -12,9 +12,9 @@ public class UIntReference : ValueReference<uint, UIntVariable>
         public UIntReference() {}
 
         /// <summary>
-        /// Creates a new uint reference with the constant value.
+        /// Creates a new uint reference with the fixed value.
         /// </summary>
-        /// <param name="value">The constant value to set.</param>
+        /// <param name="value">The fixed value to set.</param>
         public UIntReference(uint value) : base(value) {}
 
         /// <summary>
diff --git a/Runtime/Variables/ValueReference.cs b/Runtime/Variables/ValueReference.cs
@@ -3,7 +3,7 @@
 namespace Zigurous.Architecture
 {
     /// <summary>
-    /// A reference to a value of the specified type, either a constant or a variable.
+    /// A reference to a value of the specified type, either a fixed value or a variable.
     /// </summary>
     /// <typeparam name="TValue">The type of value.</typeparam>
     /// <typeparam name="TVariable">The type of variable reference.</typeparam>
@@ -12,33 +12,33 @@ public abstract class ValueReference<TValue, TVariable>
         where TVariable : ScriptableVariable<TValue>
     {
         /// <summary>
-        /// Uses a constant value instead of a variable reference.
+        /// Uses a variable reference instead of a fixed value.
         /// </summary>
-        [Tooltip("Uses a constant value instead of a variable reference.")]
-        public bool useConstant = true;
+        [Tooltip("Uses a variable reference instead of a fixed value.")]
+        public bool useVariable = false;
 
         /// <summary>
-        /// The constant value to use.
+        /// The variable to reference.
         /// </summary>
-        [Tooltip("The constant value to use.")]
-        public TValue constantValue;
+        [Tooltip("The variable to reference.")]
+        public TVariable variable = null;
 
         /// <summary>
-        /// The variable to reference.
+        /// The fixed value to use.
         /// </summary>
-        [Tooltip("The variable to reference.")]
-        public TVariable variable;
+        [Tooltip("The fixed value to use.")]
+        public TValue fixedValue = default(TValue);
 
         /// <summary>
-        /// The current value, either the constant value if set to use constant
-        /// or the value of the variable reference.
+        /// The current value, either the fixed value or the value of the
+        /// referenced variable.
         /// </summary>
         public TValue value
         {
             get
             {
-                if (useConstant) {
-                    return constantValue;
+                if (!useVariable) {
+                    return fixedValue;
                 } else if (variable != null) {
                     return variable.value;
                 } else {
@@ -53,13 +53,14 @@ public TValue value
         public ValueReference() {}
 
         /// <summary>
-        /// Creates a new value reference with the constant value.
+        /// Creates a new value reference with the fixed value.
         /// </summary>
-        /// <param name="value">The constant value to set.</param>
+        /// <param name="value">The fixed value to set.</param>
         public ValueReference(TValue value)
         {
-            this.useConstant = true;
-            this.constantValue = value;
+            useVariable = false;
+            fixedValue = value;
+            variable = null;
         }
 
         /// <summary>
@@ -68,7 +69,8 @@ public ValueReference(TValue value)
         /// <param name="variable">The variable to reference.</param>
         public ValueReference(TVariable variable)
         {
-            this.useConstant = false;
+            useVariable = true;
+            fixedValue = default(TValue);
             this.variable = variable;
         }
 
diff --git a/Runtime/Variables/Vector2IntReference.cs b/Runtime/Variables/Vector2IntReference.cs
@@ -14,9 +14,9 @@ public class Vector2IntReference : ValueReference<Vector2Int, Vector2IntVariable
         public Vector2IntReference() {}
 
         /// <summary>
-        /// Creates a new Vector2Int reference with the constant value.
+        /// Creates a new Vector2Int reference with the fixed value.
         /// </summary>
-        /// <param name="value">The constant value to set.</param>
+        /// <param name="value">The fixed value to set.</param>
         public Vector2IntReference(Vector2Int value) : base(value) {}
 
         /// <summary>
diff --git a/Runtime/Variables/Vector2Reference.cs b/Runtime/Variables/Vector2Reference.cs
@@ -14,9 +14,9 @@ public class Vector2Reference : ValueReference<Vector2, Vector2Variable>
         public Vector2Reference() {}
 
         /// <summary>
-        /// Creates a new Vector2 reference with the constant value.
+        /// Creates a new Vector2 reference with the fixed value.
         /// </summary>
-        /// <param name="value">The constant value to set.</param>
+        /// <param name="value">The fixed value to set.</param>
         public Vector2Reference(Vector2 value) : base(value) {}
 
         /// <summary>
diff --git a/Runtime/Variables/Vector3IntReference.cs b/Runtime/Variables/Vector3IntReference.cs
@@ -14,9 +14,9 @@ public class Vector3IntReference : ValueReference<Vector3Int, Vector3IntVariable
         public Vector3IntReference() {}
 
         /// <summary>
-        /// Creates a new Vector3Int reference with the constant value.
+        /// Creates a new Vector3Int reference with the fixed value.
         /// </summary>
-        /// <param name="value">The constant value to set.</param>
+        /// <param name="value">The fixed value to set.</param>
         public Vector3IntReference(Vector3Int value) : base(value) {}
 
         /// <summary>
diff --git a/Runtime/Variables/Vector3Reference.cs b/Runtime/Variables/Vector3Reference.cs
@@ -14,9 +14,9 @@ public class Vector3Reference : ValueReference<Vector3, Vector3Variable>
         public Vector3Reference() {}
 
         /// <summary>
-        /// Creates a new Vector3 reference with the constant value.
+        /// Creates a new Vector3 reference with the fixed value.
         /// </summary>
-        /// <param name="value">The constant value to set.</param>
+        /// <param name="value">The fixed value to set.</param>
         public Vector3Reference(Vector3 value) : base(value) {}
 
         /// <summary>
diff --git a/Runtime/Variables/Vector4Reference.cs b/Runtime/Variables/Vector4Reference.cs
@@ -14,9 +14,9 @@ public class Vector4Reference : ValueReference<Vector4, Vector4Variable>
         public Vector4Reference() {}
 
         /// <summary>
-        /// Creates a new Vector4 reference with the constant value.
+        /// Creates a new Vector4 reference with the fixed value.
         /// </summary>
-        /// <param name="value">The constant value to set.</param>
+        /// <param name="value">The fixed value to set.</param>
         public Vector4Reference(Vector4 value) : base(value) {}
 
         /// <summary>
