Clamped variables can now be assigned to their counter-variable type fields

Author: DanielEverland

Assets/SO Architecture/Editor/Code Generation/SO_CodeGenerationWindow.cs

@@ -124,7 +124,7 @@ private void ClampedVariableHelpBox()
         {
             if(anim.visible)
                 EditorGUILayout.HelpBox(
-                    "Clamped values are abstract and require implementation.\nAn error will be raised in your console upon creation",
+                    "Clamped variables comes with a generic clamp function, but it might need adjustments based on your type",
                     MessageType.Warning);
         }       
     }

Assets/SO Architecture/Editor/Code Generation/Templates/ClampedVariableTemplate

@@ -4,6 +4,37 @@ using UnityEngine;
     fileName = "$TYPE_NAME$ClampedVariable.asset",
     menuName = SOArchitecture_Utility.VARIABLE_CLAMPED_SUBMENU + "$MENU_NAME$",
     order = $ORDER$)]
-public class $TYPE_NAME$ClampedVariable : ClampedVariable<$TYPE$, $TYPE_NAME$Variable, $TYPE_NAME$Reference>
+public class $TYPE_NAME$ClampedVariable : $TYPE_NAME$Variable, IClampedVariable<$TYPE$, $TYPE_NAME$Variable, $TYPE_NAME$Reference>
 {
+    public $TYPE_NAME$Reference MinValue { get { return _minClampedValue; } }
+    public $TYPE_NAME$Reference MaxValue { get { return _maxClampedValue; } }
+
+    [SerializeField]
+    private $TYPE_NAME$Reference _minClampedValue;
+    [SerializeField]
+    private $TYPE_NAME$Reference _maxClampedValue;
+
+    public virtual $TYPE$ ClampValue($TYPE$ value)
+    {
+        if (value.CompareTo(MinValue.Value) < 0)
+        {
+            return MinValue.Value;
+        }            
+        else if (value.CompareTo(MaxValue.Value) > 0)
+        {
+            return MaxValue.Value;
+        }            
+        else
+        {
+            return value;
+        }            
+    }
+    public override $TYPE$ SetValue(BaseVariable<$TYPE$> value)
+    {
+        return ClampValue(value.Value);
+    }
+    public override $TYPE$ SetValue($TYPE$ value)
+    {
+        return ClampValue(value);
+    }
 }

Assets/SO Architecture/Editor/Code Generation/Templates/VariableTemplate

@@ -4,6 +4,6 @@
     fileName = "$TYPE_NAME$Variable.asset",
     menuName = SOArchitecture_Utility.VARIABLE_SUBMENU + "$MENU_NAME$",
     order = $ORDER$)]
-public sealed class $TYPE_NAME$Variable : BaseVariable<$TYPE$>
+public class $TYPE_NAME$Variable : BaseVariable<$TYPE$>
 {
 }

Assets/SO Architecture/Editor/Inspectors/BaseVariableEditor.cs

@@ -9,11 +9,14 @@
 public class BaseVariableEditor : Editor
 {
     private BaseVariable Target { get { return (BaseVariable)target; } }
+    protected bool IsClamped { get { return Target is IClampedVariable; } }
 
     private SerializedProperty _valueProperty;
     private SerializedProperty _developerDescription;
     private SerializedProperty _readOnly;
     private SerializedProperty _raiseWarning;
+    private SerializedProperty _minValueProperty;
+    private SerializedProperty _maxValueProperty;
     private AnimBool _raiseWarningAnimation;
 
     private const string READONLY_TOOLTIP = "Should this value be changable during runtime? Will still be editable in the inspector regardless";
@@ -25,6 +28,12 @@ protected virtual void OnEnable()
         _readOnly = serializedObject.FindProperty("_readOnly");
         _raiseWarning = serializedObject.FindProperty("_raiseWarning");
 
+        if (IsClamped)
+        {
+            _minValueProperty = serializedObject.FindProperty("_minClampedValue");
+            _maxValueProperty = serializedObject.FindProperty("_maxClampedValue");
+        }        
+
         _raiseWarningAnimation = new AnimBool(_readOnly.boolValue);
         _raiseWarningAnimation.valueChanged.AddListener(Repaint);
     }
@@ -33,6 +42,7 @@ public override void OnInspectorGUI()
         serializedObject.Update();
 
         DrawValue();
+        DrawClampedFields();
         DrawReadonlyField();
         DrawDeveloperDescription();
     }
@@ -63,8 +73,22 @@ protected void DrawValue()
             EditorGUILayout.LabelField(new GUIContent(labelContent, labelContent));
         }
     }
+    protected void DrawClampedFields()
+    {
+        if (!IsClamped)
+            return;
+
+        using (new EditorGUI.IndentLevelScope())
+        {
+            EditorGUILayout.PropertyField(_minValueProperty);
+            EditorGUILayout.PropertyField(_maxValueProperty);
+        }
+    }
     protected void DrawReadonlyField()
     {
+        if (IsClamped)
+            return;
+
         EditorGUILayout.PropertyField(_readOnly, new GUIContent("Read Only", READONLY_TOOLTIP));
 
         _raiseWarningAnimation.target = _readOnly.boolValue;

Assets/SO Architecture/Editor/Inspectors/ClampedVariableEditor.cs

@@ -12,6 +12,6 @@ MonoBehaviour:
   m_Name: SOArchitecture_Settings
   m_EditorClassIdentifier: 
   _drawEventGizmos: 1
-  _codeGenerationTargetDirectory: CODE_GENERATION
+  _codeGenerationTargetDirectory: SO Architecture
   _codeGenerationAllowOverwrite: 0
   _defualtCreateAssetMenuOrder: 120

Assets/SO Architecture/Resources/SOArchitecture_Settings.asset

@@ -4,6 +4,6 @@
     fileName = "ByteVariable.asset",
     menuName = SOArchitecture_Utility.ADVANCED_VARIABLE_SUBMENU + "byte",
     order = SOArchitecture_Utility.ASSET_MENU_ORDER_COLLECTIONS + 6)]
-public sealed class ByteVariable : BaseVariable<byte>
+public class ByteVariable : BaseVariable<byte>
 {
 }

Assets/SO Architecture/Variables/ByteVariable.cs

@@ -3,11 +3,38 @@
 [CreateAssetMenu(
     fileName = "ByteClampedVariable.asset",
     menuName = SOArchitecture_Utility.VARIABLE_CLAMPED_SUBMENU + "byte",
-    order = SOArchitecture_Utility.ASSET_MENU_ORDER_CLAMPED_VARIABLES + 2)]
-public class ByteClampedVariable : ClampedVariable<byte, ByteVariable, ByteReference>
+    order = 120)]
+public class ByteClampedVariable : ByteVariable, IClampedVariable<byte, ByteVariable, ByteReference>
 {
-    protected override byte ClampValue(byte value)
+    public ByteReference MinValue { get { return _minClampedValue; } }
+    public ByteReference MaxValue { get { return _maxClampedValue; } }
+
+    [SerializeField]
+    private ByteReference _minClampedValue;
+    [SerializeField]
+    private ByteReference _maxClampedValue;
+
+    public virtual byte ClampValue(byte value)
+    {
+        if (value.CompareTo(MinValue.Value) < 0)
+        {
+            return MinValue.Value;
+        }            
+        else if (value.CompareTo(MaxValue.Value) > 0)
+        {
+            return MaxValue.Value;
+        }            
+        else
+        {
+            return value;
+        }            
+    }
+    public override byte SetValue(BaseVariable<byte> value)
+    {
+        return ClampValue(value.Value);
+    }
+    public override byte SetValue(byte value)
     {
-        return (byte)Mathf.Clamp(value, MinValue.Value, MaxValue.Value);
+        return ClampValue(value);
     }
 }