TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-03-11 00:10:46 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

fill in the validated variables

Browse source
This commit is contained in:
AzaezelX 2025-03-09 11:53:23 -05:00
parent fa760fa746
commit f633ef3a3d
184 changed files with 1359 additions and 1216 deletions
Download patch file Download diff file Expand all files Collapse all files

10
Engine/source/afx/afxEffectGroup.cpp
View file

@ -143,20 +143,20 @@ void afxEffectGroupData::initPersistFields()
docsURL;
addField("groupEnabled", TypeBool, myOffset(group_enabled),
"...");
addField("count", TypeS32, myOffset(group_count),
addFieldV("count", TypeRangedS32, myOffset(group_count), &CommonValidators::NaturalNumber,
"...");
addField("indexOffset", TypeS8, myOffset(idx_offset),
"...");
addField("assignIndices", TypeBool, myOffset(assign_idx),
"...");
addField("delay", TypeF32, myOffset(timing.delay),
addFieldV("delay", TypeRangedF32, myOffset(timing.delay), &CommonValidators::PositiveFloat,
"...");
addField("lifetime", TypeF32, myOffset(timing.lifetime),
addFieldV("lifetime", TypeRangedF32, myOffset(timing.lifetime), &CommonValidators::PositiveFloat,
"...");
addField("fadeInTime", TypeF32, myOffset(timing.fade_in_time),
addFieldV("fadeInTime", TypeRangedF32, myOffset(timing.fade_in_time), &CommonValidators::PositiveFloat,
"...");
addField("fadeOutTime", TypeF32, myOffset(timing.fade_out_time),
addFieldV("fadeOutTime", TypeRangedF32, myOffset(timing.fade_out_time), &CommonValidators::PositiveFloat,
"...");
// effect lists

29
Engine/source/afx/afxEffectWrapper.cpp
View file

@ -35,6 +35,7 @@
#include "afx/afxEffectWrapper.h"
#include "afx/util/afxAnimCurve.h"
#include "afx/util/afxEase.h"
#include "console/typeValidators.h"
//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~//
// afxEffectWrapperData
@ -237,33 +238,33 @@ void afxEffectWrapperData::initPersistFields()
addField("ghostIsConstraintSrc", TypeBool, myOffset(use_ghost_as_cons_obj),
"...");
addField("delay", TypeF32, myOffset(ewd_timing.delay),
addFieldV("delay", TypeRangedF32, myOffset(ewd_timing.delay), &CommonValidators::PositiveFloat,
"...");
addField("lifetime", TypeF32, myOffset(ewd_timing.lifetime),
addFieldV("lifetime", TypeRangedF32, myOffset(ewd_timing.lifetime), &CommonValidators::PositiveFloat,
"...");
addField("fadeInTime", TypeF32, myOffset(ewd_timing.fade_in_time),
addFieldV("fadeInTime", TypeRangedF32, myOffset(ewd_timing.fade_in_time), &CommonValidators::PositiveFloat,
"...");
addField("residueLifetime", TypeF32, myOffset(ewd_timing.residue_lifetime),
addFieldV("residueLifetime", TypeRangedF32, myOffset(ewd_timing.residue_lifetime), &CommonValidators::PositiveFloat,
"...");
addField("fadeInEase", TypePoint2F, myOffset(ewd_timing.fadein_ease),
"...");
addField("fadeOutEase", TypePoint2F, myOffset(ewd_timing.fadeout_ease),
"...");
addField("lifetimeBias", TypeF32, myOffset(ewd_timing.life_bias),
addFieldV("lifetimeBias", TypeRangedF32, myOffset(ewd_timing.life_bias), &CommonValidators::PositiveFloat,
"...");
addField("fadeOutTime", TypeF32, myOffset(user_fade_out_time),
addFieldV("fadeOutTime", TypeRangedF32, myOffset(user_fade_out_time), &CommonValidators::PositiveFloat,
"...");
addField("rateFactor", TypeF32, myOffset(rate_factor),
addFieldV("rateFactor", TypeRangedF32, myOffset(rate_factor), &CommonValidators::PositiveFloat,
"...");
addField("scaleFactor", TypeF32, myOffset(scale_factor),
addFieldV("scaleFactor", TypeRangedF32, myOffset(scale_factor), &CommonValidators::PositiveFloat,
"...");
addField("isLooping", TypeBool, myOffset(is_looping),
"...");
addField("loopCount", TypeS32, myOffset(n_loops),
addFieldV("loopCount", TypeRangedS32, myOffset(n_loops), &CommonValidators::PositiveInt,
"...");
addField("loopGapTime", TypeF32, myOffset(loop_gap_time),
addFieldV("loopGapTime", TypeRangedF32, myOffset(loop_gap_time), &CommonValidators::PositiveFloat,
"...");
addField("ignoreTimeFactor", TypeBool, myOffset(ignore_time_factor),
@ -296,9 +297,9 @@ void afxEffectWrapperData::initPersistFields()
"...");
addField("direction", TypePoint3F, myOffset(direction),
"...");
addField("speed", TypeF32, myOffset(speed),
addFieldV("speed", TypeRangedF32, myOffset(speed), &CommonValidators::PositiveFloat,
"...");
addField("mass", TypeF32, myOffset(mass),
addFieldV("mass", TypeRangedF32, myOffset(mass), &CommonValidators::PositiveFloat,
"...");
addField("borrowAltitudes", TypeBool, myOffset(borrow_altitudes),
@ -739,9 +740,9 @@ afxEffectWrapper::~afxEffectWrapper()
void afxEffectWrapper::initPersistFields()
{
docsURL;
addField("liveScaleFactor", TypeF32, myOffset(mLive_scale_factor),
addFieldV("liveScaleFactor", TypeRangedF32, myOffset(mLive_scale_factor), &CommonValidators::PositiveFloat,
"...");
addField("liveFadeFactor", TypeF32, myOffset(mLive_fade_factor),
addFieldV("liveFadeFactor", TypeRangedF32, myOffset(mLive_fade_factor), &CommonValidators::PositiveFloat,
"...");
Parent::initPersistFields();

4
Engine/source/afx/afxEffectron.cpp
View file

@ -111,9 +111,9 @@ void afxEffectronData::reloadReset()
void afxEffectronData::initPersistFields()
{
docsURL;
addField("duration", TypeF32, myOffset(duration),
addFieldV("duration", TypeRangedF32, myOffset(duration), &CommonValidators::PositiveFloat,
"...");
addField("numLoops", TypeS32, myOffset(n_loops),
addFieldV("numLoops", TypeRangedS32, myOffset(n_loops), &CommonValidators::NegDefaultInt,
"...");
// effect lists
// for each of these, dummy_fx_entry is set and then a validator adds it to the appropriate effects list

39
Engine/source/afx/afxMagicMissile.cpp
View file

@ -324,8 +324,9 @@ afxMagicMissileData* afxMagicMissileData::cloneAndPerformSubstitutions(const Sim
FRangeValidator muzzleVelocityValidator(0, 10000);
FRangeValidator missilePrecisionValidator(0.f, 100.f);
FRangeValidator missileTrackDelayValidator(0, 100000);
IRangeValidator missileTrackDelayValidator(0, 100000);
FRangeValidator missileBallisticCoefficientValidator(0, 1);
FRangeValidator missileFollowTerrainAdjustRateValidator(0.05f, FLT_MAX);
void afxMagicMissileData::initPersistFields()
{
@ -353,36 +354,36 @@ void afxMagicMissileData::initPersistFields()
endGroup("Light Emitter");
addGroup("Physics");
addNamedFieldV(lifetime, TypeS32, afxMagicMissileData, &ticksFromMS);
addFieldV("casterSafetyTime", TypeS32, myOffset(caster_safety_time), &ticksFromMS);
addNamedFieldV(lifetime, TypeRangedS32, afxMagicMissileData, &ticksFromMS);
addFieldV("casterSafetyTime", TypeRangedS32, myOffset(caster_safety_time), &ticksFromMS);
addField("isBallistic", TypeBool, Offset(isBallistic, afxMagicMissileData));
addNamedFieldV(muzzleVelocity, TypeF32, afxMagicMissileData, &muzzleVelocityValidator);
addNamedFieldV(ballisticCoefficient, TypeF32, afxMagicMissileData, &missileBallisticCoefficientValidator);
addField("gravityMod", TypeF32, Offset(gravityMod, afxMagicMissileData));
addNamedFieldV(muzzleVelocity, TypeRangedF32, afxMagicMissileData, &muzzleVelocityValidator);
addNamedFieldV(ballisticCoefficient, TypeRangedF32, afxMagicMissileData, &missileBallisticCoefficientValidator);
addFieldV("gravityMod", TypeRangedF32, Offset(gravityMod, afxMagicMissileData), &CommonValidators::F32Range);
addField("collisionMask", TypeS32, myOffset(collision_mask));
addField("startingVelocityVector",TypePoint3F, myOffset(starting_vel_vec));
addNamedField(acceleration, TypeF32, afxMagicMissileData);
addNamedFieldV(accelDelay, TypeS32, afxMagicMissileData, &ticksFromMS);
addNamedFieldV(accelLifetime, TypeS32, afxMagicMissileData, &ticksFromMS);
addNamedFieldV(accelDelay, TypeRangedS32, afxMagicMissileData, &ticksFromMS);
addNamedFieldV(accelLifetime, TypeRangedS32, afxMagicMissileData, &ticksFromMS);
addField("reverseTargeting", TypeBool, myOffset(reverse_targeting));
endGroup("Physics");
addGroup("Physics-Tracking");
addNamedField(isGuided, TypeBool, afxMagicMissileData);
addNamedFieldV(precision, TypeF32, afxMagicMissileData, &missilePrecisionValidator);
addNamedFieldV(trackDelay, TypeS32, afxMagicMissileData, &missileTrackDelayValidator);
addNamedFieldV(precision, TypeRangedF32, afxMagicMissileData, &missilePrecisionValidator);
addNamedFieldV(trackDelay, TypeRangedS32, afxMagicMissileData, &missileTrackDelayValidator);
endGroup("Physics-Tracking");
addGroup("Physics-Avoidance");
addField("followTerrain", TypeBool, myOffset(followTerrain));
addField("followTerrainHeight", TypeF32, myOffset(followTerrainHeight));
addField("followTerrainAdjustRate", TypeF32, myOffset(followTerrainAdjustRate));
addFieldV("followTerrainAdjustDelay", TypeS32, myOffset(followTerrainAdjustDelay), &ticksFromMS);
addFieldV("followTerrainHeight", TypeRangedS32, myOffset(followTerrainHeight), &CommonValidators::PositiveFloat);
addFieldV("followTerrainAdjustRate", TypeRangedS32, myOffset(followTerrainAdjustRate), &missileFollowTerrainAdjustRateValidator);
addFieldV("followTerrainAdjustDelay", TypeRangedS32, myOffset(followTerrainAdjustDelay), &ticksFromMS);
addField("hoverAltitude", TypeF32, myOffset(hover_altitude));
addField("hoverAttackDistance", TypeF32, myOffset(hover_attack_distance));
addField("hoverAttackGradient", TypeF32, myOffset(hover_attack_gradient));
addFieldV("hoverTime", TypeS32, myOffset(hover_time), &ticksFromMS);
addFieldV("hoverAltitude", TypeRangedF32, myOffset(hover_altitude), &CommonValidators::PositiveFloat);
addFieldV("hoverAttackDistance", TypeRangedF32, myOffset(hover_attack_distance), &CommonValidators::PositiveFloat);
addFieldV("hoverAttackGradient", TypeRangedF32, myOffset(hover_attack_gradient), &CommonValidators::PositiveNonZeroFloat);
addFieldV("hoverTime", TypeRangedS32, myOffset(hover_time), &ticksFromMS);
endGroup("Physics-Avoidance");
addGroup("Physics-Launch");
@ -391,8 +392,8 @@ void afxMagicMissileData::initPersistFields()
addField("launchOffsetServer",TypePoint3F, myOffset(launch_offset_server));
addField("launchOffsetClient",TypePoint3F, myOffset(launch_offset_client));
addField("launchNodeOffset", TypePoint3F, myOffset(launch_node_offset));
addField("launchAimPitch", TypeF32, myOffset(launch_pitch));
addField("launchAimPan", TypeF32, myOffset(launch_pan));
addFieldV("launchAimPitch", TypeRangedF32, myOffset(launch_pitch), &CommonValidators::DegreeRange);
addFieldV("launchAimPan", TypeRangedF32, myOffset(launch_pan), &CommonValidators::DegreeRange);
addField("launchConstraintServer", TypeString, myOffset(launch_cons_s_spec));
addField("launchConstraintClient", TypeString, myOffset(launch_cons_c_spec));
addField("echoLaunchOffset", TypeBool, myOffset(echo_launch_offset));

20
Engine/source/afx/afxMagicSpell.cpp
View file

@ -220,22 +220,22 @@ void afxMagicSpellData::initPersistFields()
// for each effect list, dummy_fx_entry is set and then a validator adds it to the appropriate effects list
addGroup("Casting Stage");
addField("castingDur", TypeF32, myOffset(mCasting_dur),
addFieldV("castingDur", TypeRangedF32, myOffset(mCasting_dur), &CommonValidators::PositiveFloat,
"...");
addField("numCastingLoops", TypeS32, myOffset(mNum_casting_loops),
addFieldV("numCastingLoops", TypeRangedS32, myOffset(mNum_casting_loops), &CommonValidators::NaturalNumber,
"...");
addField("extraCastingTime", TypeF32, myOffset(mExtra_casting_time),
addFieldV("extraCastingTime", TypeRangedF32, myOffset(mExtra_casting_time), &CommonValidators::PositiveFloat,
"...");
addFieldV("addCastingEffect", TYPEID<afxEffectBaseData>(), Offset(mDummy_fx_entry, afxMagicSpellData), &_castingPhrase,
"...");
endGroup("Casting Stage");
addGroup("Delivery Stage");
addField("deliveryDur", TypeF32, myOffset(mDelivery_dur),
addFieldV("deliveryDur", TypeRangedF32, myOffset(mDelivery_dur), &CommonValidators::PositiveFloat,
"...");
addField("numDeliveryLoops", TypeS32, myOffset(mNum_delivery_loops),
addFieldV("numDeliveryLoops", TypeRangedS32, myOffset(mNum_delivery_loops), &CommonValidators::NaturalNumber,
"...");
addField("extraDeliveryTime", TypeF32, myOffset(mExtra_delivery_time),
addFieldV("extraDeliveryTime", TypeRangedF32, myOffset(mExtra_delivery_time), &CommonValidators::PositiveFloat,
"...");
addFieldV("addLaunchEffect", TYPEID<afxEffectBaseData>(), Offset(mDummy_fx_entry, afxMagicSpellData), &_launchPhrase,
"...");
@ -244,11 +244,11 @@ void afxMagicSpellData::initPersistFields()
endGroup("Delivery Stage");
addGroup("Linger Stage");
addField("lingerDur", TypeF32, myOffset(mLinger_dur),
addFieldV("lingerDur", TypeRangedF32, myOffset(mLinger_dur), &CommonValidators::PositiveFloat,
"...");
addField("numLingerLoops", TypeS32, myOffset(mNum_linger_loops),
addFieldV("numLingerLoops", TypeRangedS32, myOffset(mNum_linger_loops), &CommonValidators::NaturalNumber,
"...");
addField("extraLingerTime", TypeF32, myOffset(mExtra_linger_time),
addFieldV("extraLingerTime", TypeRangedF32, myOffset(mExtra_linger_time), &CommonValidators::PositiveFloat,
"...");
addFieldV("addImpactEffect", TYPEID<afxEffectBaseData>(), Offset(mDummy_fx_entry, afxMagicSpellData), &_impactPhrase,
"...");
@ -259,7 +259,7 @@ void afxMagicSpellData::initPersistFields()
// interrupt flags
addField("allowMovementInterrupts", TypeBool, myOffset(mDo_move_interrupts),
"...");
addField("movementInterruptSpeed", TypeF32, myOffset(mMove_interrupt_speed),
addFieldV("movementInterruptSpeed", TypeRangedF32, myOffset(mMove_interrupt_speed), &CommonValidators::PositiveFloat,
"...");
// delivers projectile spells

18
Engine/source/afx/afxSelectron.cpp
View file

@ -153,17 +153,17 @@ void afxSelectronData::initPersistFields()
static ewValidator _selectPhrase(SELECT_PHRASE);
static ewValidator _deselectPhrase(DESELECT_PHRASE);
addField("mainDur", TypeF32, myOffset(main_dur),
addFieldV("mainDur", TypeRangedF32, myOffset(main_dur), &CommonValidators::PositiveFloat,
"...");
addField("selectDur", TypeF32, myOffset(select_dur),
addFieldV("selectDur", TypeRangedF32, myOffset(select_dur), &CommonValidators::PositiveFloat,
"...");
addField("deselectDur", TypeF32, myOffset(deselect_dur),
addFieldV("deselectDur", TypeRangedF32, myOffset(deselect_dur), &CommonValidators::PositiveFloat,
"...");
addField("mainRepeats", TypeS32, myOffset(n_main_loops),
addFieldV("mainRepeats", TypeRangedS32, myOffset(n_main_loops), &CommonValidators::NaturalNumber,
"...");
addField("selectRepeats", TypeS32, myOffset(n_select_loops),
addFieldV("selectRepeats", TypeRangedS32, myOffset(n_select_loops), &CommonValidators::NaturalNumber,
"...");
addField("deselectRepeats", TypeS32, myOffset(n_deselect_loops),
addFieldV("deselectRepeats", TypeRangedS32, myOffset(n_deselect_loops), &CommonValidators::NaturalNumber,
"...");
addField("selectionTypeMask", TypeS32, myOffset(obj_type_mask),
"...");
@ -180,11 +180,11 @@ void afxSelectronData::initPersistFields()
"...");
// deprecated
addField("numMainLoops", TypeS32, myOffset(n_main_loops),
addFieldV("numMainLoops", TypeRangedS32, myOffset(n_main_loops), &CommonValidators::NaturalNumber,
"...");
addField("numSelectLoops", TypeS32, myOffset(n_select_loops),
addFieldV("numSelectLoops", TypeRangedS32, myOffset(n_select_loops), &CommonValidators::NaturalNumber,
"...");
addField("numDeselectLoops", TypeS32, myOffset(n_deselect_loops),
addFieldV("numDeselectLoops", TypeRangedS32, myOffset(n_deselect_loops), &CommonValidators::NaturalNumber,
"...");
Parent::initPersistFields();

4
Engine/source/afx/ce/afxAnimClip.cpp
View file

@ -106,11 +106,11 @@ void afxAnimClipData::initPersistFields()
"The name of an animation sequence to be played by a ShapeBase-derived object to which this effect is "
"constrained. Also works on afxModel effects.\n"
"default: \"\"\n");
addField("rate", TYPEID< F32 >(), myOffset(rate),
addFieldV("rate", TypeRangedF32, myOffset(rate), &CommonValidators::F32Range,
"The desired playback speed for the sequence. A value of 1.0 indicates forward playback at a normal rate. Negative "
"values cause the sequence to play backwards.\n"
"default: 1.0\n");
addField("posOffset", TYPEID< F32 >(), myOffset(pos_offset),
addFieldV("posOffset", TypeRangedF32, myOffset(pos_offset), &CommonValidators::NormalizedFloat,
"Sets a starting offset for the selected animation clip. It directly specifies an animation thread position in the 0.0 to "
"1.0 range as a fraction of the clip's duration.\n"
"default: 1.0\n");

6
Engine/source/afx/ce/afxAreaDamage.cpp
View file

@ -79,13 +79,13 @@ void afxAreaDamageData::initPersistFields()
"An arbitrary string which is passed as an argument to a spell's onDamage() script "
"method. It is used to classify a type of damage such as 'melee', 'magical', or "
"'fire'.");
addField("damage", TypeF32, myOffset(amount),
addFieldV("damage", TypeRangedF32, myOffset(amount), &CommonValidators::F32Range,
"An amount of area damage to inflict on a target. Objects within half the radius "
"receive full damage which then diminishes out to the full distance of the specified "
"radius.");
addField("radius", TypeF32, myOffset(radius),
addFieldV("radius", TypeRangedF32, myOffset(radius), &CommonValidators::PositiveFloat,
"Radius centered at the effect position in which damage will be applied.");
addField("impulse", TypeF32, myOffset(impulse),
addFieldV("impulse", TypeRangedF32, myOffset(impulse), &CommonValidators::F32Range,
"Specifies an amount of force to apply to damaged objects. Objects within half the "
"radius receive full impulse which then diminishes out to the full distance of the "
"specified radius.");

3
Engine/source/afx/ce/afxAudioBank.cpp
View file

@ -30,6 +30,7 @@
#include "sfx/sfxDescription.h"
#include "afx/ce/afxAudioBank.h"
#include "console/typeValidators.h"
//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~//
@ -133,7 +134,7 @@ void afxAudioBank::initPersistFields()
"SFXDescription datablock to use with this set of sounds.");
addField("preload", TypeBool, Offset(mPreload, afxAudioBank),
"If set to true, file is pre-loaded, otherwise it is loaded on-demand.");
addField("playIndex", TypeS32, Offset(play_index, afxAudioBank),
addFieldV("playIndex", TypeRangedS32, Offset(play_index, afxAudioBank), &CommonValidators::NegDefaultInt,
"An array index that selects a sound to play from the filenames[] field. Values "
"outside of the range of assigned filename[] entries will not play any sound.");

4
Engine/source/afx/ce/afxCameraShake.cpp
View file

@ -71,9 +71,9 @@ void afxCameraShakeData::initPersistFields()
"The camera shake frequencies for all three axes: X, Y, Z.");
addField("amplitude", TypePoint3F, Offset(camShakeAmp, afxCameraShakeData),
"The camera shake amplitudes for all three axes: X, Y, Z.");
addField("radius", TypeF32, Offset(camShakeRadius, afxCameraShakeData),
addFieldV("radius", TypeRangedF32, Offset(camShakeRadius, afxCameraShakeData), &CommonValidators::PositiveFloat,
"Radius about the effect position in which shaking will be applied.");
addField("falloff", TypeF32, Offset(camShakeFalloff, afxCameraShakeData),
addFieldV("falloff", TypeRangedF32, Offset(camShakeFalloff, afxCameraShakeData), &CommonValidators::PositiveFloat,
"Magnitude by which shaking decreases over distance to radius.");
Parent::initPersistFields();

8
Engine/source/afx/ce/afxDamage.cpp
View file

@ -83,19 +83,19 @@ void afxDamageData::initPersistFields()
"An arbitrary string which is passed as an argument to a spell's onDamage() script "
"method. It is used to classify a type of damage such as 'melee', 'magical', or "
"'fire'.");
addField("directDamage", TypeF32, myOffset(amount),
addFieldV("directDamage", TypeRangedF32, myOffset(amount), &CommonValidators::F32Range,
"An amount of direct damage to inflict on a target.");
addField("directDamageRepeats", TypeS8, myOffset(repeats),
"The number of times to inflict the damage specified by directDamage. Values "
"greater than 1 inflict damage over time, with the amount of directDamage "
"repeatedly dealt at evenly spaced intervals over the lifetime of the effect.");
addField("areaDamage", TypeF32, myOffset(ad_amount),
addFieldV("areaDamage", TypeRangedF32, myOffset(ad_amount), &CommonValidators::F32Range,
"An amount of area damage to inflict on a target. Objects within half the radius "
"receive full damage which then diminishes out to the full distance of "
"areaDamageRadius.");
addField("areaDamageRadius", TypeF32, myOffset(radius),
addFieldV("areaDamageRadius", TypeRangedF32, myOffset(radius), &CommonValidators::PositiveFloat,
"Radius centered at the effect position in which damage will be applied.");
addField("areaDamageImpulse", TypeF32, myOffset(impulse),
addFieldV("areaDamageImpulse", TypeRangedF32, myOffset(impulse), &CommonValidators::F32Range,
"Specifies an amount of force to apply to damaged objects. Objects within half the "
"radius receive full impulse which then diminishes out to the full distance of "
"areaDamageRadius.");

10
Engine/source/afx/ce/afxLightBase_T3D.cpp
View file

@ -104,11 +104,11 @@ void afxT3DLightBaseData::initPersistFields()
"Enables/Disables the object rendering and functionality in the scene.");
addField( "color", TypeColorF, Offset( mColor, afxT3DLightBaseData ),
"Changes the base color hue of the light.");
addField( "brightness", TypeF32, Offset( mBrightness, afxT3DLightBaseData ),
addFieldV( "brightness", TypeRangedF32, Offset( mBrightness, afxT3DLightBaseData ), &CommonValidators::PositiveFloat,
"Adjusts the lights power, 0 being off completely.");
addField( "castShadows", TypeBool, Offset( mCastShadows, afxT3DLightBaseData ),
"Enables/disables shadow casts by this light.");
addField( "priority", TypeF32, Offset( mPriority, afxT3DLightBaseData ),
addFieldV( "priority", TypeRangedF32, Offset( mPriority, afxT3DLightBaseData ), &CommonValidators::PositiveFloat,
"Used for sorting of lights by the light manager. Priority determines if a light "
"has a stronger effect than, those with a lower value");
addField( "localRenderViz", TypeBool, Offset( mLocalRenderViz, afxT3DLightBaseData ),
@ -123,9 +123,9 @@ void afxT3DLightBaseData::initPersistFields()
"Toggles animation for the light on and off");
addField( "animationType", TYPEID<LightAnimData>(), Offset( mAnimationData, afxT3DLightBaseData ),
"Datablock containing light animation information (LightAnimData)");
addField( "animationPeriod", TypeF32, Offset( mAnimState.animationPeriod, afxT3DLightBaseData ),
addFieldV( "animationPeriod", TypeRangedF32, Offset( mAnimState.animationPeriod, afxT3DLightBaseData ), &CommonValidators::PositiveFloat,
"The length of time in seconds for a single playback of the light animation");
addField( "animationPhase", TypeF32, Offset( mAnimState.animationPhase, afxT3DLightBaseData ),
addFieldV( "animationPhase", TypeRangedF32, Offset( mAnimState.animationPhase, afxT3DLightBaseData ), &CommonValidators::PositiveFloat,
"The phase used to offset the animation start time to vary the animation of "
"nearby lights.");
@ -135,7 +135,7 @@ void afxT3DLightBaseData::initPersistFields()
addField( "flareType", TYPEID<LightFlareData>(), Offset( mFlareData, afxT3DLightBaseData ),
"Datablock containing light flare information (LightFlareData)");
addField( "flareScale", TypeF32, Offset( mFlareScale, afxT3DLightBaseData ),
addFieldV( "flareScale", TypeRangedF32, Offset( mFlareScale, afxT3DLightBaseData ), &CommonValidators::PositiveFloat,
"Globally scales all features of the light flare");
endGroup( "Misc" );

3
Engine/source/afx/ce/afxMachineGun.cpp
View file

@ -31,6 +31,7 @@
#include "T3D/projectile.h"
#include "afx/ce/afxMachineGun.h"
#include "console/typeValidators.h"
//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~//
// afxMachineGunData
@ -68,7 +69,7 @@ void afxMachineGunData::initPersistFields()
docsURL;
addField("projectile", TYPEID<ProjectileData>(), myOffset(projectile_data),
"A ProjectileData datablock describing the projectile to be launched.");
addField("roundsPerMinute", TypeS32, myOffset(rounds_per_minute),
addFieldV("roundsPerMinute", TypeRangedS32, myOffset(rounds_per_minute), &CommonValidators::PositiveInt,
"Specifies the number of projectiles fired over a minute of time. A value of 1200 "
"will create 20 projectiles per second.\n"
"Sample values for real machine guns:\n"

8
Engine/source/afx/ce/afxModel.cpp
View file

@ -180,18 +180,18 @@ void afxModelData::initPersistFields()
addGroup("Animation");
addField("sequence", TypeString, myOffset(sequence),
"The name of an animation sequence to play in the model.");
addField("sequenceRate", TypeF32, myOffset(seq_rate),
addFieldV("sequenceRate", TypeRangedF32, myOffset(seq_rate), &CommonValidators::F32Range,
"The rate of playback for the sequence.");
addField("sequenceOffset", TypeF32, myOffset(seq_offset),
addFieldV("sequenceOffset", TypeRangedF32, myOffset(seq_offset), &CommonValidators::F32Range,
"An offset in seconds indicating a starting point for the animation sequence "
"specified by the sequence field. A rate of 1.0 (rather than sequenceRate) is used "
"to convert from seconds to the thread offset.");
endGroup("Animation");
addGroup("Rendering");
addField("alphaMult", TypeF32, myOffset(alpha_mult),
addFieldV("alphaMult", TypeRangedF32, myOffset(alpha_mult), &CommonValidators::PositiveFloat,
"An alpha multiplier used to set maximum opacity of the model.");
addField("fogMult", TypeF32, myOffset(fog_mult), "");
addFieldV("fogMult", TypeRangedF32, myOffset(fog_mult), &CommonValidators::PositiveFloat, "");
addField("remapTextureTags", TypeString, myOffset(remap_txr_tags),
"Rename one or more texture tags in the model. Texture tags are what link a "
"model's textures to materials.\n"

10
Engine/source/afx/ce/afxParticleEmitter.cpp
View file

@ -292,9 +292,9 @@ afxParticleEmitterConeData::afxParticleEmitterConeData(const afxParticleEmitterC
void afxParticleEmitterConeData::initPersistFields()
{
docsURL;
addField("spreadMin", TypeF32, Offset(spread_min, afxParticleEmitterConeData),
addFieldV("spreadMin", TypeRangedF32, Offset(spread_min, afxParticleEmitterConeData), &CommonValidators::PosDegreeRangeHalf,
"...");
addField("spreadMax", TypeF32, Offset(spread_max, afxParticleEmitterConeData),
addFieldV("spreadMax", TypeRangedF32, Offset(spread_max, afxParticleEmitterConeData), &CommonValidators::PosDegreeRangeHalf,
"...");
Parent::initPersistFields();
@ -416,7 +416,7 @@ void afxParticleEmitterPathData::initPersistFields()
"...");
addField("groundConformInteriors", TypeBool, Offset(ground_conform_interiors, afxParticleEmitterPathData),
"...");
addField("groundConformHeight", TypeF32, Offset(ground_conform_height, afxParticleEmitterPathData),
addFieldV("groundConformHeight", TypeRangedF32, Offset(ground_conform_height, afxParticleEmitterPathData), &CommonValidators::PositiveFloat,
"...");
Parent::initPersistFields();
@ -647,9 +647,9 @@ afxParticleEmitterDiscData::afxParticleEmitterDiscData(const afxParticleEmitterD
void afxParticleEmitterDiscData::initPersistFields()
{
docsURL;
addField("radiusMin", TypeF32, Offset(pe_radius_min, afxParticleEmitterDiscData),
addFieldV("radiusMin", TypeRangedF32, Offset(pe_radius_min, afxParticleEmitterDiscData), &CommonValidators::PositiveFloat,
"...");
addField("radiusMax", TypeF32, Offset(pe_radius_max, afxParticleEmitterDiscData),
addFieldV("radiusMax", TypeRangedF32, Offset(pe_radius_max, afxParticleEmitterDiscData), &CommonValidators::PositiveFloat,
"...");
Parent::initPersistFields();

4
Engine/source/afx/ce/afxPhraseEffect.cpp
View file

@ -140,11 +140,11 @@ EndImplementEnumType;
void afxPhraseEffectData::initPersistFields()
{
docsURL;
addField("duration", TypeF32, myOffset(duration),
addFieldV("duration", TypeRangedF32, myOffset(duration), &CommonValidators::NegDefaultF32,
"Specifies a duration for the phrase-effect. If set to infinity, the phrase-effect "
"needs to have a phraseType of continuous. Set infinite duration using "
"$AFX::INFINITE_TIME.");
addField("numLoops", TypeS32, myOffset(n_loops),
addFieldV("numLoops", TypeRangedS32, myOffset(n_loops), &CommonValidators::NegDefaultInt,
"Specifies the number of times the phrase-effect should loop. If set to infinity, "
"the phrase-effect needs to have a phraseType of continuous. Set infinite looping "
"using $AFX::INFINITE_REPEATS.");

6
Engine/source/afx/ce/afxPhysicalZone.cpp
View file

@ -73,13 +73,15 @@ afxPhysicalZoneData::afxPhysicalZoneData(const afxPhysicalZoneData& other, bool
#define myOffset(field) Offset(field, afxPhysicalZoneData)
FRangeValidator afxVelocityModRange(-40.0f, 40.0f);
FRangeValidator afxGravityModRange(-40.0f, 40.0f);
void afxPhysicalZoneData::initPersistFields()
{
docsURL;
addField("velocityMod", TypeF32, myOffset(mVelocityMod),
addFieldV("velocityMod", TypeRangedF32, myOffset(mVelocityMod), &afxVelocityModRange,
"A multiplier that biases the velocity of an object every tick it is within the "
"zone.");
addField("gravityMod", TypeF32, myOffset(mGravityMod),
addFieldV("gravityMod", TypeRangedF32, myOffset(mGravityMod), &afxGravityModRange,
"A multiplier that biases the influence of gravity on objects within the zone.");
addField("appliedForce", TypePoint3F, myOffset(mAppliedForce),
"A three-valued vector representing a directional force applied to objects withing "

2
Engine/source/afx/ce/afxPlayerMovement.cpp
View file

@ -81,7 +81,7 @@ EndImplementEnumType;
void afxPlayerMovementData::initPersistFields()
{
docsURL;
addField("speedBias", TypeF32, myOffset(speed_bias),
addFieldV("speedBias", TypeRangedF32, myOffset(speed_bias), &CommonValidators::F32Range,
"A floating-point multiplier that scales the constraint Player's movement speed.");
addField("movement", TypePoint3F, myOffset(movement),
"");

2
Engine/source/afx/ce/afxPointLight_T3D.cpp
View file

@ -65,7 +65,7 @@ void afxT3DPointLightData::initPersistFields()
docsURL;
addGroup( "Light" );
addField( "radius", TypeF32, Offset( mRadius, afxT3DPointLightData ),
addFieldV( "radius", TypeRangedF32, Offset( mRadius, afxT3DPointLightData ), &CommonValidators::PositiveFloat,
"Controls the falloff of the light emission");
endGroup( "Light" );

6
Engine/source/afx/ce/afxSpotLight_T3D.cpp
View file

@ -69,11 +69,11 @@ void afxT3DSpotLightData::initPersistFields()
docsURL;
addGroup( "Light" );
addField( "range", TypeF32, Offset( mRange, afxT3DSpotLightData ),
addFieldV( "range", TypeRangedF32, Offset( mRange, afxT3DSpotLightData ), &CommonValidators::PositiveFloat,
"...");
addField( "innerAngle", TypeF32, Offset( mInnerConeAngle, afxT3DSpotLightData ),
addFieldV( "innerAngle", TypeRangedF32, Offset( mInnerConeAngle, afxT3DSpotLightData ), &CommonValidators::DegreeRangeQuarter,
"...");
addField( "outerAngle", TypeF32, Offset( mOuterConeAngle, afxT3DSpotLightData ),
addFieldV( "outerAngle", TypeRangedF32, Offset( mOuterConeAngle, afxT3DSpotLightData ), &CommonValidators::DegreeRangeQuarter,
"...");
endGroup( "Light" );

20
Engine/source/afx/ce/afxZodiac.cpp
View file

@ -158,7 +158,7 @@ void afxZodiacData::initPersistFields()
{
docsURL;
INITPERSISTFIELD_IMAGEASSET(Texture, afxZodiacData, "An image to use as the zodiac's texture.");
addField("radius", TypeF32, Offset(radius_xy, afxZodiacData),
addFieldV("radius", TypeRangedF32, Offset(radius_xy, afxZodiacData), &CommonValidators::PositiveFloat,
"The zodiac's radius in scene units.");
addField("verticalRange", TypePoint2F, Offset(vert_range, afxZodiacData),
"For interior zodiacs only, verticalRange specifies distances above and below the "
@ -167,18 +167,18 @@ void afxZodiacData::initPersistFields()
"Specifies if the zodiac's verticalRange should scale according to changes in the "
"radius. When a zodiacs is used as an expanding shockwave, this value should be set "
"to false, otherwise the zodiac can expand to cover an entire interior.");
addField("startAngle", TypeF32, Offset(start_ang, afxZodiacData),
addFieldV("startAngle", TypeRangedF32, Offset(start_ang, afxZodiacData), &CommonValidators::DegreeRange,
"The starting angle in degrees of the zodiac's rotation.");
addField("rotationRate", TypeF32, Offset(ang_per_sec, afxZodiacData),
addFieldV("rotationRate", TypeRangedF32, Offset(ang_per_sec, afxZodiacData), &CommonValidators::DegreeRange,
"The rate of rotation in degrees-per-second. Zodiacs with a positive rotationRate "
"rotate clockwise, while those with negative values turn counter-clockwise.");
addField("growInTime", TypeF32, Offset(grow_in_time, afxZodiacData),
addFieldV("growInTime", TypeRangedF32, Offset(grow_in_time, afxZodiacData), &CommonValidators::PositiveFloat,
"A duration of time in seconds over which the zodiac grows from a zero size to its "
"full size as specified by the radius.");
addField("shrinkOutTime", TypeF32, Offset(shrink_out_time, afxZodiacData),
addFieldV("shrinkOutTime", TypeRangedF32, Offset(shrink_out_time, afxZodiacData), &CommonValidators::PositiveFloat,
"A duration of time in seconds over which the zodiac shrinks from full size to "
"invisible.");
addField("growthRate", TypeF32, Offset(growth_rate, afxZodiacData),
addFieldV("growthRate", TypeRangedF32, Offset(growth_rate, afxZodiacData), &CommonValidators::F32Range,
"A rate in meters-per-second at which the zodiac grows in size. A negative value will "
"shrink the zodiac.");
addField("color", TypeColorF, Offset(color, afxZodiacData),
@ -215,20 +215,20 @@ void afxZodiacData::initPersistFields()
addField("interiorIgnoreTransparent", TypeBool, Offset(interior_transp_ignore, afxZodiacData),
"");
addField("altitudeMax", TypeF32, Offset(altitude_max, afxZodiacData),
addFieldV("altitudeMax", TypeRangedF32, Offset(altitude_max, afxZodiacData), &CommonValidators::F32Range,
"The altitude at which zodiac becomes invisible as the result of fading out or "
"becoming too small.");
addField("altitudeFalloff", TypeF32, Offset(altitude_falloff, afxZodiacData),
addFieldV("altitudeFalloff", TypeRangedF32, Offset(altitude_falloff, afxZodiacData), &CommonValidators::F32Range,
"The altitude at which zodiac begins to fade and/or shrink.");
addField("altitudeShrinks", TypeBool, Offset(altitude_shrinks, afxZodiacData),
"When true, zodiac becomes smaller as altitude increases.");
addField("altitudeFades", TypeBool, Offset(altitude_fades, afxZodiacData),
"When true, zodiac fades out as altitude increases.");
addField("distanceMax", TypeF32, Offset(distance_max, afxZodiacData),
addFieldV("distanceMax", TypeRangedF32, Offset(distance_max, afxZodiacData), &CommonValidators::PositiveFloat,
"The distance from camera at which the zodiac becomes invisible as the result of "
"fading out.");
addField("distanceFalloff", TypeF32, Offset(distance_falloff, afxZodiacData),
addFieldV("distanceFalloff", TypeRangedF32, Offset(distance_falloff, afxZodiacData), &CommonValidators::PositiveFloat,
"The distance from camera at which the zodiac begins to fade out.");
addField("useGradientRange", TypeBool, Offset(use_grade_range, afxZodiacData),

12
Engine/source/afx/ce/afxZodiacPlane.cpp
View file

@ -114,20 +114,20 @@ void afxZodiacPlaneData::initPersistFields()
docsURL;
INITPERSISTFIELD_IMAGEASSET(Texture, afxZodiacPlaneData, "An image to use as the zodiac's texture.");
addField("radius", TypeF32, myOffset(radius_xy),
addFieldV("radius", TypeRangedF32, myOffset(radius_xy), &CommonValidators::PositiveFloat,
"The zodiac's radius in scene units.");
addField("startAngle", TypeF32, myOffset(start_ang),
addFieldV("startAngle", TypeRangedF32, myOffset(start_ang), &CommonValidators::DegreeRange,
"The starting angle in degrees of the zodiac's rotation.");
addField("rotationRate", TypeF32, myOffset(ang_per_sec),
addFieldV("rotationRate", TypeRangedF32, myOffset(ang_per_sec), &CommonValidators::DegreeRange,
"The rate of rotation in degrees-per-second. Zodiacs with a positive rotationRate "
"rotate clockwise, while those with negative values turn counter-clockwise.");
addField("growInTime", TypeF32, myOffset(grow_in_time),
addFieldV("growInTime", TypeRangedF32, myOffset(grow_in_time), &CommonValidators::PositiveFloat,
"A duration of time in seconds over which the zodiac grows from a zero size to its "
"full size as specified by the radius.");
addField("shrinkOutTime", TypeF32, myOffset(shrink_out_time),
addFieldV("shrinkOutTime", TypeRangedF32, myOffset(shrink_out_time), &CommonValidators::PositiveFloat,
"A duration of time in seconds over which the zodiac shrinks from full size to "
"invisible.");
addField("growthRate", TypeF32, myOffset(growth_rate),
addFieldV("growthRate", TypeRangedF32, myOffset(growth_rate), &CommonValidators::F32Range,
"A rate in meters-per-second at which the zodiac grows in size. A negative value will "
"shrink the zodiac.");
addField("color", TypeColorF, myOffset(color),

2
Engine/source/afx/ea/afxEA_Zodiac.cpp
View file

@ -399,7 +399,7 @@ void afxEA_Zodiac::initPersistFields()
docsURL;
addField("liveColor", TypeColorF, myOffset(live_color),
"...");
addField("liveColorFactor", TypeF32, myOffset(live_color_factor),
addFieldV("liveColorFactor", TypeRangedF32, myOffset(live_color_factor), &CommonValidators::PositiveFloat,
"...");
Parent::initPersistFields();

4
Engine/source/afx/forces/afxF_Drag.cpp
View file

@ -103,9 +103,9 @@ afxF_DragData::afxF_DragData(const afxF_DragData& other, bool temp_clone) : afxF
void afxF_DragData::initPersistFields()
{
docsURL;
addField("drag", TypeF32, myOffset(drag_coefficient),
addFieldV("drag", TypeRangedF32, myOffset(drag_coefficient), &CommonValidators::PositiveNonZeroFloat,
"...");
addField("airDensity", TypeF32, myOffset(air_density),
addFieldV("airDensity", TypeRangedF32, myOffset(air_density), &CommonValidators::PositiveNonZeroFloat,
"...");
addField("crossSectionalArea", TypeF32, myOffset(cross_sectional_area),
"...");

2
Engine/source/afx/forces/afxF_Gravity.cpp
View file

@ -95,7 +95,7 @@ afxF_GravityData::afxF_GravityData(const afxF_GravityData& other, bool temp_clon
void afxF_GravityData::initPersistFields()
{
docsURL;
addField("gravity", TypeF32, myOffset(gravity),
addFieldV("gravity", TypeRangedF32, myOffset(gravity), &CommonValidators::F32Range,
"...");
Parent::initPersistFields();

6
Engine/source/afx/rpg/afxRPGMagicSpell.cpp
View file

@ -91,9 +91,9 @@ void afxRPGMagicSpellData::initPersistFields()
addField("target", TYPEID< afxRPGMagicSpellData::TargetType >(), myOffset(spell_target),
"...");
addField("range", TypeF32, myOffset(spell_range),
addFieldV("range", TypeRangedF32, myOffset(spell_range), &CommonValidators::PositiveFloat,
"...");
addField("manaCost", TypeS32, myOffset(mana_cost),
addFieldV("manaCost", TypeRangedS32, myOffset(mana_cost), &CommonValidators::PositiveInt,
"...");
addField("reagentCost", TypeS8, myOffset(reagent_cost), MAX_REAGENTS_PER_SPELL,
"...");
@ -101,7 +101,7 @@ void afxRPGMagicSpellData::initPersistFields()
"...");
// spell phase timing
addField("castingDur", TypeF32, myOffset(casting_dur));
addFieldV("castingDur", TypeRangedF32, myOffset(casting_dur), &CommonValidators::PositiveFloat);
// interface elements
addField("iconBitmap", TypeFilename, myOffset(icon_name));

4
Engine/source/afx/ui/afxGuiTextHud.cpp
View file

@ -75,9 +75,9 @@ void afxGuiTextHud::initPersistFields()
"...");
addField( "showFrame", TypeBool, Offset( mShowFrame, afxGuiTextHud ),
"...");
addField( "verticalOffset", TypeF32, Offset( mVerticalOffset, afxGuiTextHud ),
addFieldV( "verticalOffset", TypeRangedF32, Offset( mVerticalOffset, afxGuiTextHud ), &CommonValidators::F32Range,
"...");
addField( "distanceFade", TypeF32, Offset( mDistanceFade, afxGuiTextHud ),
addFieldV( "distanceFade", TypeRangedF32, Offset( mDistanceFade, afxGuiTextHud ), &CommonValidators::PositiveFloat,
"...");
addField( "labelAllShapes", TypeBool, Offset( mLabelAllShapes, afxGuiTextHud ),
"...");

2
Engine/source/afx/util/afxParticlePool.cpp
View file

@ -75,7 +75,7 @@ void afxParticlePoolData::initPersistFields()
"...");
addField("baseColor", TypeColorF, Offset(base_color, afxParticlePoolData),
"...");
addField("blendWeight", TypeF32, Offset(blend_weight, afxParticlePoolData),
addFieldV("blendWeight", TypeRangedF32, Offset(blend_weight, afxParticlePoolData), &CommonValidators::PositiveFloat,
"...");
Parent::initPersistFields();

8
Engine/source/afx/util/afxPath.cpp
View file

@ -151,13 +151,13 @@ void afxPathData::initPersistFields()
"...");
addField("loop", TypeString, Offset(loop_string, afxPathData),
"...");
addField("mult", TypeF32, Offset(mult, afxPathData),
addFieldV("mult", TypeRangedF32, Offset(mult, afxPathData), &CommonValidators::F32Range,
"...");
addField("delay", TypeF32, Offset(delay, afxPathData),
addFieldV("delay", TypeRangedF32, Offset(delay, afxPathData), &CommonValidators::PositiveFloat,
"...");
addField("lifetime", TypeF32, Offset(lifetime, afxPathData),
addFieldV("lifetime", TypeRangedF32, Offset(lifetime, afxPathData), &CommonValidators::PositiveFloat,
"...");
addField("timeOffset", TypeF32, Offset(time_offset, afxPathData),
addFieldV("timeOffset", TypeRangedF32, Offset(time_offset, afxPathData), &CommonValidators::F32Range,
"...");
addField("reverse", TypeBool, Offset(reverse, afxPathData),
"...");

2
Engine/source/afx/xm/afxXM_AltitudeConform.cpp
View file

@ -109,7 +109,7 @@ afxXM_AltitudeConformData::afxXM_AltitudeConformData(const afxXM_AltitudeConform
void afxXM_AltitudeConformData::initPersistFields()
{
docsURL;
addField("height", TypeF32, Offset(height, afxXM_AltitudeConformData),
addFieldV("height", TypeRangedF32, Offset(height, afxXM_AltitudeConformData), &CommonValidators::F32Range,
"...");
addField("conformToTerrain", TypeBool, Offset(do_terrain, afxXM_AltitudeConformData),
"...");

2
Engine/source/afx/xm/afxXM_BoxAdapt.cpp
View file

@ -99,7 +99,7 @@ afxXM_BoxAdaptData::afxXM_BoxAdaptData(const afxXM_BoxAdaptData& other, bool tem
void afxXM_BoxAdaptData::initPersistFields()
{
docsURL;
addField("scaleFactor", TypeF32, Offset(scale_factor, afxXM_BoxAdaptData),
addFieldV("scaleFactor", TypeRangedF32, Offset(scale_factor, afxXM_BoxAdaptData), &CommonValidators::PositiveFloat,
"...");
addField("dimensionRange", TypePoint2F, Offset(dim_range, afxXM_BoxAdaptData),
"...");

2
Engine/source/afx/xm/afxXM_Freeze.cpp
View file

@ -163,7 +163,7 @@ void afxXM_FreezeData::initPersistFields()
docsURL;
addField("mask", TypeS32, Offset(mask, afxXM_FreezeData),
"...");
addField("delay", TypeF32, Offset(delay, afxXM_FreezeData),
addFieldV("delay", TypeRangedF32, Offset(delay, afxXM_FreezeData), &CommonValidators::PositiveFloat,
"...");
Parent::initPersistFields();

2
Engine/source/afx/xm/afxXM_GroundConform.cpp
View file

@ -101,7 +101,7 @@ afxXM_GroundConformData::afxXM_GroundConformData(const afxXM_GroundConformData&
void afxXM_GroundConformData::initPersistFields()
{
docsURL;
addField("height", TypeF32, Offset(height, afxXM_GroundConformData),
addFieldV("height", TypeRangedF32, Offset(height, afxXM_GroundConformData), &CommonValidators::F32Range,
"...");
addField("conformToTerrain", TypeBool, Offset(do_terrain, afxXM_GroundConformData),
"...");

2
Engine/source/afx/xm/afxXM_Oscillate.cpp
View file

@ -166,7 +166,7 @@ void afxXM_OscillateData::initPersistFields()
"...");
addField("max", TypePoint3F, Offset(max, afxXM_OscillateData),
"...");
addField("speed", TypeF32, Offset(speed, afxXM_OscillateData),
addFieldV("speed", TypeRangedF32, Offset(speed, afxXM_OscillateData), &CommonValidators::PositiveFloat,
"...");
addField("axis", TypePoint3F, Offset(axis, afxXM_OscillateData),
"...");

2
Engine/source/afx/xm/afxXM_OscillateZodiacColor.cpp
View file

@ -94,7 +94,7 @@ void afxXM_OscillateZodiacColorData::initPersistFields()
"...");
addField("colorB", TypeColorF, Offset(color_b, afxXM_OscillateZodiacColorData),
"...");
addField("speed", TypeF32, Offset(speed, afxXM_OscillateZodiacColorData),
addFieldV("speed", TypeRangedF32, Offset(speed, afxXM_OscillateZodiacColorData), &CommonValidators::PositiveFloat,
"...");
Parent::initPersistFields();

8
Engine/source/afx/xm/afxXM_RandomRot.cpp
View file

@ -109,13 +109,13 @@ void afxXM_RandomRotData::initPersistFields()
docsURL;
addField("axis", TypePoint3F, Offset(axis, afxXM_RandomRotData),
"...");
addField("thetaMin", TypeF32, Offset(theta_min, afxXM_RandomRotData),
addFieldV("thetaMin", TypeRangedF32, Offset(theta_min, afxXM_RandomRotData), &CommonValidators::PosDegreeRangeHalf,
"...");
addField("thetaMax", TypeF32, Offset(theta_max, afxXM_RandomRotData),
addFieldV("thetaMax", TypeRangedF32, Offset(theta_max, afxXM_RandomRotData), &CommonValidators::PosDegreeRangeHalf,
"...");
addField("phiMin", TypeF32, Offset(phi_min, afxXM_RandomRotData),
addFieldV("phiMin", TypeRangedF32, Offset(phi_min, afxXM_RandomRotData), &CommonValidators::PosDegreeRange,
"...");
addField("phiMax", TypeF32, Offset(phi_max, afxXM_RandomRotData),
addFieldV("phiMax", TypeRangedF32, Offset(phi_max, afxXM_RandomRotData), &CommonValidators::PosDegreeRange,
"...");
Parent::initPersistFields();

2
Engine/source/afx/xm/afxXM_Shockwave.cpp
View file

@ -103,7 +103,7 @@ afxXM_ShockwaveData::afxXM_ShockwaveData(const afxXM_ShockwaveData& other, bool
void afxXM_ShockwaveData::initPersistFields()
{
docsURL;
addField("rate", TypeF32, Offset(rate, afxXM_ShockwaveData),
addFieldV("rate", TypeRangedF32, Offset(rate, afxXM_ShockwaveData), &CommonValidators::PositiveFloat,
"...");
addField("aimZOnly", TypeBool, Offset(aim_z_only, afxXM_ShockwaveData),
"...");

8
Engine/source/afx/xm/afxXM_Spin.cpp
View file

@ -122,13 +122,13 @@ void afxXM_SpinData::initPersistFields()
docsURL;
addField("spinAxis", TypePoint3F, Offset(spin_axis, afxXM_SpinData),
"...");
addField("spinAngle", TypeF32, Offset(spin_angle, afxXM_SpinData),
addFieldV("spinAngle", TypeRangedF32, Offset(spin_angle, afxXM_SpinData), &CommonValidators::DegreeRange,
"...");
addField("spinAngleVariance", TypeF32, Offset(spin_angle_var, afxXM_SpinData),
addFieldV("spinAngleVariance", TypeRangedF32, Offset(spin_angle_var, afxXM_SpinData), &CommonValidators::DegreeRange,
"...");
addField("spinRate", TypeF32, Offset(spin_rate, afxXM_SpinData),
addFieldV("spinRate", TypeRangedF32, Offset(spin_rate, afxXM_SpinData), &CommonValidators::DegreeRange,
"...");
addField("spinRateVariance", TypeF32, Offset(spin_rate_var, afxXM_SpinData),
addFieldV("spinRateVariance", TypeRangedF32, Offset(spin_rate_var, afxXM_SpinData), &CommonValidators::DegreeRange,
"...");
Parent::initPersistFields();

2
Engine/source/afx/xm/afxXM_VelocityOffset.cpp
View file

@ -166,7 +166,7 @@ afxXM_VelocityOffsetData::afxXM_VelocityOffsetData(const afxXM_VelocityOffsetDat
void afxXM_VelocityOffsetData::initPersistFields()
{
docsURL;
addField("offsetFactor", TypeF32, Offset(offset_factor, afxXM_VelocityOffsetData),
addFieldV("offsetFactor", TypeRangedF32, Offset(offset_factor, afxXM_VelocityOffsetData), &CommonValidators::F32Range,
"...");
addField("offsetPos2", TypeBool, Offset(offset_pos2, afxXM_VelocityOffsetData),
"...");

18
Engine/source/afx/xm/afxXM_WaveBase.cpp
View file

@ -151,28 +151,28 @@ void afxXM_WaveBaseData::initPersistFields()
addField("op", TYPEID< afxXM_WaveBaseData::WaveOpType >(), Offset(op, afxXM_WaveBaseData),
"...");
addField("speed", TypeF32, Offset(speed, afxXM_WaveBaseData),
addFieldV("speed", TypeRangedF32, Offset(speed, afxXM_WaveBaseData), &CommonValidators::PositiveFloat,
"waves per second");
addField("speedVariance", TypeF32, Offset(speed_vari, afxXM_WaveBaseData),
addFieldV("speedVariance", TypeRangedF32, Offset(speed_vari, afxXM_WaveBaseData), &CommonValidators::PositiveFloat,
"...");
addField("acceleration", TypeF32, Offset(accel, afxXM_WaveBaseData),
addFieldV("acceleration", TypeRangedF32, Offset(accel, afxXM_WaveBaseData), &CommonValidators::PositiveFloat,
"...");
addField("phaseShift", TypeF32, Offset(phase_shift, afxXM_WaveBaseData),
addFieldV("phaseShift", TypeRangedF32, Offset(phase_shift, afxXM_WaveBaseData), &CommonValidators::PositiveFloat,
"...");
addField("dutyCycle", TypeF32, Offset(duty_cycle, afxXM_WaveBaseData),
addFieldV("dutyCycle", TypeRangedF32, Offset(duty_cycle, afxXM_WaveBaseData), &CommonValidators::PositiveFloat,
"...");
addField("dutyShift", TypeF32, Offset(duty_shift, afxXM_WaveBaseData),
addFieldV("dutyShift", TypeRangedF32, Offset(duty_shift, afxXM_WaveBaseData), &CommonValidators::PositiveFloat,
"...");
addField("offDutyT", TypeF32, Offset(off_duty_t, afxXM_WaveBaseData),
addFieldV("offDutyT", TypeRangedF32, Offset(off_duty_t, afxXM_WaveBaseData), &CommonValidators::PositiveFloat,
"...");
addField("wavesPerPulse", TypeByteRange2, Offset(waves_per_pulse, afxXM_WaveBaseData),
"...");
addField("wavesPerRest", TypeByteRange2, Offset(waves_per_rest, afxXM_WaveBaseData),
"...");
addField("restDuration", TypeF32, Offset(rest_dur, afxXM_WaveBaseData),
addFieldV("restDuration", TypeRangedF32, Offset(rest_dur, afxXM_WaveBaseData), &CommonValidators::PositiveFloat,
"...");
addField("restDurationVariance", TypeF32, Offset(rest_dur_vari, afxXM_WaveBaseData),
addFieldV("restDurationVariance", TypeRangedF32, Offset(rest_dur_vari, afxXM_WaveBaseData), &CommonValidators::PositiveFloat,
"...");
addField("axis", TypePoint3F, Offset(axis, afxXM_WaveBaseData),

10
Engine/source/afx/xm/afxXfmMod.cpp
View file

@ -215,19 +215,19 @@ F32 afxXM_WeightedBaseData::getWeightFactor() const
void afxXM_WeightedBaseData::initPersistFields()
{
docsURL;
addField("delay", TypeF32, Offset(delay, afxXM_WeightedBaseData),
addFieldV("delay", TypeRangedF32, Offset(delay, afxXM_WeightedBaseData), &CommonValidators::PositiveFloat,
"...");
addField("lifetime", TypeF32, Offset(lifetime, afxXM_WeightedBaseData),
addFieldV("lifetime", TypeRangedF32, Offset(lifetime, afxXM_WeightedBaseData), &CommonValidators::PositiveFloat,
"...");
addField("fadeInTime", TypeF32, Offset(fade_in_time, afxXM_WeightedBaseData),
addFieldV("fadeInTime", TypeRangedF32, Offset(fade_in_time, afxXM_WeightedBaseData), &CommonValidators::PositiveFloat,
"...");
addField("fadeOutTime", TypeF32, Offset(fade_out_time, afxXM_WeightedBaseData),
addFieldV("fadeOutTime", TypeRangedF32, Offset(fade_out_time, afxXM_WeightedBaseData), &CommonValidators::PositiveFloat,
"...");
addField("fadeInEase", TypePoint2F, Offset(fadein_ease, afxXM_WeightedBaseData),
"...");
addField("fadeOutEase", TypePoint2F, Offset(fadeout_ease, afxXM_WeightedBaseData),
"...");
addField("lifetimeBias", TypeF32, Offset(life_bias, afxXM_WeightedBaseData),
addFieldV("lifetimeBias", TypeRangedF32, Offset(life_bias, afxXM_WeightedBaseData), &CommonValidators::F32Range,
"...");
Parent::initPersistFields();