add numerous new validators

as well as inspector support to treat a significant chunk of the codebase as range-clmped values which can take a guisliderbarctrl with a configurable at the validator level fidelity variable
additionally adds a new addfieldV and addprotetedfieldV for further callback validated slider-presented variables
*also* adds an on additional callbacks to the inspector itself, like onPreinspectobject, onPostinspectObject, and onPostInspectorfieldModified
in addition to *that*, adds a new hidefield command to tag a given specific field not to show in inspector

Engine/source/console/consoleObject.cpp

@@ -624,6 +624,86 @@ void ConsoleObject::addProtectedField(const char*  in_pFieldname,
    sg_tempFieldList.push_back(f);
 }
 
+void ConsoleObject::addProtectedFieldV(const char* in_pFieldname,
+   const U32 in_fieldType,
+   const dsize_t in_fieldOffset,
+   AbstractClassRep::SetDataNotify in_setDataFn,
+   AbstractClassRep::GetDataNotify in_getDataFn,
+   AbstractClassRep::WriteDataNotify in_writeDataFn,
+   TypeValidator* v,
+   const U32 in_elementCount,
+   const char* in_pFieldDocs,
+   U32 flags)
+{
+   AbstractClassRep::Field f;
+   f.pFieldname = StringTable->insert(in_pFieldname);
+
+   if (in_pFieldDocs)
+      f.pFieldDocs = in_pFieldDocs;
+
+   f.type = in_fieldType;
+   f.offset = in_fieldOffset;
+   f.elementCount = in_elementCount;
+   f.validator = v;
+   f.flag = flags;
+
+   f.setDataFn = in_setDataFn;
+   f.getDataFn = in_getDataFn;
+   f.writeDataFn = in_writeDataFn;
+   f.networkMask = 0;
+
+   ConsoleBaseType* conType = ConsoleBaseType::getType(in_fieldType);
+   AssertFatal(conType, "ConsoleObject::addProtectedField - invalid console type");
+   f.table = conType->getEnumTable();
+
+   sg_tempFieldList.push_back(f);
+}
+
+void ConsoleObject::addProtectedFieldV(const char* in_pFieldname,
+   const U32     in_fieldType,
+   const dsize_t in_fieldOffset,
+   AbstractClassRep::SetDataNotify in_setDataFn,
+   AbstractClassRep::GetDataNotify in_getDataFn,
+   TypeValidator* v,
+   const U32 in_elementCount,
+   const char* in_pFieldDocs,
+   U32 flags)
+{
+   addProtectedFieldV(
+      in_pFieldname,
+      in_fieldType,
+      in_fieldOffset,
+      in_setDataFn,
+      in_getDataFn,
+      &defaultProtectedWriteFn,
+      v,
+      in_elementCount,
+      in_pFieldDocs,
+      flags);
+}
+
+void ConsoleObject::addProtectedFieldV(const char* in_pFieldname,
+   const U32     in_fieldType,
+   const dsize_t in_fieldOffset,
+   AbstractClassRep::SetDataNotify in_setDataFn,
+   AbstractClassRep::GetDataNotify in_getDataFn,
+   TypeValidator* v,
+   const char* in_pFieldDocs,
+   U32 flags)
+{
+   addProtectedFieldV(
+      in_pFieldname,
+      in_fieldType,
+      in_fieldOffset,
+      in_setDataFn,
+      in_getDataFn,
+      &defaultProtectedWriteFn,
+      v,
+      1,
+      in_pFieldDocs,
+      flags);
+}
+
 void ConsoleObject::addFieldV(const char*  in_pFieldname,
                        const U32 in_fieldType,
                        const dsize_t in_fieldOffset,
@@ -648,6 +728,32 @@ void ConsoleObject::addFieldV(const char*  in_pFieldname,
    sg_tempFieldList.push_back(f);
 }
 
+void ConsoleObject::addFieldV(const char* in_pFieldname,
+   const U32 in_fieldType,
+   const dsize_t in_fieldOffset,
+   TypeValidator* v,
+   const U32 in_elementCount,
+   const char* in_pFieldDocs)
+{
+   AbstractClassRep::Field f;
+   f.pFieldname = StringTable->insert(in_pFieldname);
+   if (in_pFieldDocs)
+      f.pFieldDocs = in_pFieldDocs;
+   f.type = in_fieldType;
+   f.offset = in_fieldOffset;
+   f.elementCount = 1;
+   f.table = NULL;
+   f.setDataFn = &defaultProtectedSetFn;
+   f.getDataFn = &defaultProtectedGetFn;
+   f.writeDataFn = &defaultProtectedWriteFn;
+   f.elementCount = in_elementCount;
+   f.validator = v;
+   f.networkMask = 0;
+   v->fieldIndex = sg_tempFieldList.size();
+
+   sg_tempFieldList.push_back(f);
+}
+
 void ConsoleObject::addDeprecatedField(const char *fieldName)
 {
    AbstractClassRep::Field f;

Engine/source/console/consoleObject.h

@@ -945,6 +945,13 @@ public:
       TypeValidator *v,
       const char *   in_pFieldDocs = NULL);
 
+   static void addFieldV(const char* in_pFieldname,
+      const U32      in_fieldType,
+      const dsize_t  in_fieldOffset,
+      TypeValidator* v,
+      const U32     in_elementCount,
+      const char* in_pFieldDocs = NULL);
+
    /// Register a complex protected field.
    ///
    /// @param  in_pFieldname     Name of the field.
@@ -998,6 +1005,37 @@ public:
       const char* in_pFieldDocs = NULL,
       U32 flags = 0);
 
+
+   static void addProtectedFieldV(const char* in_pFieldname,
+      const U32     in_fieldType,
+      const dsize_t in_fieldOffset,
+      AbstractClassRep::SetDataNotify in_setDataFn,
+      AbstractClassRep::GetDataNotify in_getDataFn = &defaultProtectedGetFn,
+      AbstractClassRep::WriteDataNotify in_writeDataFn = &defaultProtectedWriteFn,
+      TypeValidator* v  = NULL,
+      const U32     in_elementCount = 1,
+      const char* in_pFieldDocs = NULL,
+      U32 flags = 0);
+
+   static void addProtectedFieldV(const char* in_pFieldname,
+      const U32     in_fieldType,
+      const dsize_t in_fieldOffset,
+      AbstractClassRep::SetDataNotify in_setDataFn,
+      AbstractClassRep::GetDataNotify in_getDataFn = &defaultProtectedGetFn,
+      TypeValidator* v = NULL,
+      const U32     in_elementCount = 1,
+      const char* in_pFieldDocs = NULL,
+      U32 flags = 0);
+
+   static void addProtectedFieldV(const char* in_pFieldname,
+      const U32     in_fieldType,
+      const dsize_t in_fieldOffset,
+      AbstractClassRep::SetDataNotify in_setDataFn,
+      AbstractClassRep::GetDataNotify in_getDataFn = &defaultProtectedGetFn,
+      TypeValidator* v = NULL,
+      const char* in_pFieldDocs = NULL,
+      U32 flags = 0);
+
    /// Add a deprecated field.
    ///
    /// A deprecated field will always be undefined, even if you assign a value to it. This

Engine/source/console/consoleTypes.cpp

@@ -473,6 +473,48 @@ ConsoleSetType( TypeF32 )
       Con::printf("(TypeF32) Cannot set multiple args to a single F32.");
 }
 
+//-----------------------------------------------------------------------------
+// TypeRangedF32
+//-----------------------------------------------------------------------------
+ConsoleType(float, TypeRangedF32, F32, "")
+
+ConsoleGetType(TypeRangedF32)
+{
+   static const U32 bufSize = 256;
+   char* returnBuffer = Con::getReturnBuffer(bufSize);
+   dSprintf(returnBuffer, bufSize, "%g", *((F32*)dptr));
+   return returnBuffer;
+}
+ConsoleSetType(TypeRangedF32)
+{
+   if (argc == 1)
+      *((F32*)dptr) = dAtof(argv[0]);
+   else
+      Con::printf("(TypeF32) Cannot set multiple args to a single F32.");
+}
+
+//-----------------------------------------------------------------------------
+// TypeRangedS32
+//-----------------------------------------------------------------------------
+ConsoleType(int, TypeRangedS32, S32, "")
+
+ConsoleGetType(TypeRangedS32)
+{
+   static const U32 bufSize = 512;
+   char* returnBuffer = Con::getReturnBuffer(bufSize);
+   dSprintf(returnBuffer, bufSize, "%d", *((S32*)dptr));
+   return returnBuffer;
+}
+
+ConsoleSetType(TypeRangedS32)
+{
+   if (argc == 1)
+      *((S32*)dptr) = dAtoi(argv[0]);
+   else
+      Con::printf("(TypeRangedS32) Cannot set multiple args to a single S32.");
+}
+
+
 //-----------------------------------------------------------------------------
 // TypeF32Vector
 //-----------------------------------------------------------------------------

Engine/source/console/consoleTypes.h

@@ -66,9 +66,11 @@ DefineConsoleType( TypeBoolVector, Vector<bool>)
 DefineConsoleType( TypeS8,  S8 )
 DefineConsoleType( TypeS16, S16)
 DefineConsoleType( TypeS32, S32 )
+DefineConsoleType(TypeRangedS32, S32)
 DefineConsoleType( TypeS32Vector, Vector<S32> )
 DefineConsoleType( TypeF64, F64 )
 DefineConsoleType( TypeF32, F32 )
+DefineConsoleType( TypeRangedF32, F32)
 DefineConsoleType( TypeF32Vector, Vector<F32> )
 DefineUnmappedConsoleType( TypeString, const char * ) // plain UTF-8 strings are not supported in new interop
 DefineConsoleType( TypeCaseString, const char * )

Engine/source/console/typeValidators.cpp

@@ -100,9 +100,42 @@ void Point3NormalizeValidator::validateType(SimObject *object, void *typePtr)
 
 namespace CommonValidators
 {
-   FRangeValidator PositiveFloat(0.0f, F32_MAX);
+   FRangeValidator F32Range(F32_MIN, F32_MAX, F32_MAX);
+   FRangeValidator DirFloat(-1.0f, 1.0f);
+   FRangeValidator NegDefaultF32(-1.0f, F32_MAX, F32_MAX);
+   FRangeValidator PositiveFloat(0.0f, F32_MAX, F32_MAX);
    FRangeValidator PositiveNonZeroFloat((F32)POINT_EPSILON, F32_MAX);
    FRangeValidator NormalizedFloat(0.0f, 1.0f);
+
+   FRangeValidator F32_8BitPercent(0.0f, 1.0f, 1 << 8);
+   FRangeValidator F32_16BitPercent(0.0f, 1.0f, 1 << 16);
+   FRangeValidator ValidSlopeAngle(0.0f, 89.9f, 89.9f);
+   FRangeValidator CornerAngle(0.0f, 90.0f, 90.0f);
+
+   IRangeValidator S32Range(S32_MIN, S32_MAX);
+   IRangeValidator DirInt(-1,1);
+   IRangeValidator NegDefaultInt(-1, S32_MAX);
+   IRangeValidator PositiveInt(0, S32_MAX);
+   IRangeValidator NaturalNumber(1, S32_MAX);
+   //see "T3D/gameBase/processList.h" for TickMs = 32
+   IRangeValidator MSTickRange(32, S32_MAX);
+
+   IRangeValidator S32_8BitCap(0, 1 << 8);
+   IRangeValidator S32_16BitCap(0, 1 << 16);
    Point3NormalizeValidator NormalizedPoint3(1.0f);
+
+   FRangeValidator DegreeRange(-360.0f, 360.0f, 720.0f);
+   FRangeValidator PosDegreeRange(0.0f, 360.0f, 360.0f);
+   FRangeValidator DegreeRangeHalf(-180.0f, 180.0f, 360.0f);
+   FRangeValidator PosDegreeRangeHalf(0.0f, 180.0f, 180.0f);
+   FRangeValidator DegreeRangeQuarter(-90.0f, 90.0f, 180.0f);
+   FRangeValidator PosDegreeRangeQuarter(0.0f, 90.0f, 90.0f);
+
+   IRangeValidator S32_DegreeRange(-360, 360);
+   IRangeValidator S32_PosDegreeRange(0, 360);
+   IRangeValidator S32_DegreeRangeHalf(-180, 180);
+   IRangeValidator S32_PosDegreeRangeHalf(0, 180);
+   IRangeValidator S32_DegreeRangeQuarter(-90, 90);
+   IRangeValidator S32_PosDegreeRangeQuarter(0, 90);
 };
 

Engine/source/console/typeValidators.h

@@ -46,31 +46,35 @@ class TypeValidator
 /// Floating point min/max range validator
 class FRangeValidator : public TypeValidator
 {
-   F32 minV, maxV;
+   F32 minV, maxV, mFidelity;
 public:
-   FRangeValidator(F32 minValue, F32 maxValue)
+   FRangeValidator(F32 minValue, F32 maxValue, F32 fidelity = 0.0f)
    {
       minV = minValue;
       maxV = maxValue;
+      mFidelity = fidelity;
    }
    void validateType(SimObject *object, void *typePtr) override;
    F32 getMin() { return minV; };
    F32 getMax() { return maxV; };
+   F32 getFidelity() { return mFidelity; };
 };
 
 /// Signed integer min/max range validator
 class IRangeValidator : public TypeValidator
 {
-   S32 minV, maxV;
+   S32 minV, maxV, mFidelity;
 public:
-   IRangeValidator(S32 minValue, S32 maxValue)
+   IRangeValidator(S32 minValue, S32 maxValue, S32 fidelity = 1)
    {
       minV = minValue;
       maxV = maxValue;
+      mFidelity = fidelity;
    }
    void validateType(SimObject *object, void *typePtr) override;
-   F32 getMin() { return minV; };
-   F32 getMax() { return maxV; };
+   S32 getMin() { return minV; };
+   S32 getMax() { return maxV; };
+   S32 getFidelity() { return mFidelity; };
 };
 
 /// Scaled integer field validator
@@ -89,6 +93,9 @@ public:
       factor = scaleFactor;
    }
    void validateType(SimObject *object, void *typePtr) override;
+   S32 getMin() { return minV; };
+   S32 getMax() { return maxV; };
+   S32 getScaleFactor() { return factor; };
 };
 
 /// Vector normalization validator
@@ -104,12 +111,42 @@ public:
 namespace CommonValidators
 {
    // Floats
+   extern FRangeValidator F32Range;
+   extern FRangeValidator DirFloat;
+   extern FRangeValidator NegDefaultF32;   
    extern FRangeValidator PositiveFloat;
    extern FRangeValidator PositiveNonZeroFloat;
    extern FRangeValidator NormalizedFloat;
+   extern FRangeValidator F32_8BitPercent;
+   extern FRangeValidator F32_16BitPercent;
+   extern FRangeValidator ValidSlopeAngle;
+   extern FRangeValidator CornerAngle;
 
+   extern IRangeValidator S32Range;
+   extern IRangeValidator DirInt;
+   extern IRangeValidator NegDefaultInt;
+   extern IRangeValidator PositiveInt;
+   extern IRangeValidator NaturalNumber;
+   extern IRangeValidator MSTickRange;
+   extern IRangeValidator S32_8BitCap;
+   extern IRangeValidator S32_16BitCap;
    // Other Math Types
    extern Point3NormalizeValidator NormalizedPoint3;
+
+   // orbital mechanics
+   extern FRangeValidator DegreeRange;
+   extern FRangeValidator PosDegreeRange;
+   extern FRangeValidator DegreeRangeHalf;
+   extern FRangeValidator PosDegreeRangeHalf;
+   extern FRangeValidator DegreeRangeQuarter;
+   extern FRangeValidator PosDegreeRangeQuarter;
+
+   extern IRangeValidator S32_DegreeRange;
+   extern IRangeValidator S32_PosDegreeRange;
+   extern IRangeValidator S32_DegreeRangeHalf;
+   extern IRangeValidator S32_PosDegreeRangeHalf;
+   extern IRangeValidator S32_DegreeRangeQuarter;
+   extern IRangeValidator S32_PosDegreeRangeQuarter;
 };
 
 #endif