//--------------------------------------------------------------------------
void Projectile::initPersistFields()
{
addGroup("Physics");
addProtectedField("initialPosition", TypePoint3F, Offset(mInitialPosition, Projectile), &_setInitialPosition, &defaultProtectedGetFn,
"@brief Starting position for the projectile.\n\n");
//addField("initialPosition", TypePoint3F, Offset(mCurrPosition, Projectile),
// "@brief Starting position for the projectile.\n\n");
addProtectedField("initialVelocity", TypePoint3F, Offset(mInitialVelocity, Projectile), &_setInitialVelocity, &defaultProtectedGetFn,
"@brief Starting velocity for the projectile.\n\n");
//addField("initialVelocity", TypePoint3F, Offset(mCurrVelocity, Projectile),
// "@brief Starting velocity for the projectile.\n\n");
endGroup("Physics");
addGroup("Source");
addField("sourceObject", TypeS32, Offset(mSourceObjectId, Projectile),
"@brief ID number of the object that fired the projectile.\n\n"
"@note If the projectile was fired by a WeaponImage, sourceObject will be "
"the object that owns the WeaponImage. This is usually the player.");
addField("sourceSlot", TypeS32, Offset(mSourceObjectSlot, Projectile),
"@brief The sourceObject's weapon slot that the projectile originates from.\n\n");
endGroup("Source");
Parent::initPersistFields();
}
void TimeOfDay::initPersistFields()
{
addGroup( "TimeOfDay" );
addField( "axisTilt", TypeF32, Offset( mAxisTilt, TimeOfDay ),
"The angle in degrees between global equator and tropic." );
addProtectedField( "dayLength", TypeF32, Offset( mDayLen, TimeOfDay ), &setDayLength, &defaultProtectedGetFn,
"The length of a virtual day in real world seconds." );
addField( "startTime", TypeF32, Offset( mStartTimeOfDay, TimeOfDay ),
"" );
addProtectedField( "time", TypeF32, Offset( mTimeOfDay, TimeOfDay ), &setTimeOfDay, &defaultProtectedGetFn, "Current time of day." );
addProtectedField( "play", TypeBool, Offset( mPlay, TimeOfDay ), &setPlay, &defaultProtectedGetFn, "True when the TimeOfDay object is operating." );
addField( "azimuthOverride", TypeF32, Offset( mAzimuthOverride, TimeOfDay ), "" );
addField( "dayScale", TypeF32, Offset( mDayScale, TimeOfDay ), "Scalar applied to time that elapses while the sun is up." );
addField( "nightScale", TypeF32, Offset( mNightScale, TimeOfDay ), "Scalar applied to time that elapses while the sun is down." );
endGroup( "TimeOfDay" );
Parent::initPersistFields();
}
void VEvent::initPersistFields( void )
{
Parent::initPersistFields();
addProtectedField( "TriggerTime", TypeS32, Offset( mTriggerTime, VEvent ), &setTriggerTime, &defaultProtectedGetFn, "The time that this event is triggered." );
addProtectedField( "Duration", TypeS32, Offset( mDuration, VEvent ), &setDuration, &defaultProtectedGetFn, "The total duration that this event plays for." );
}
void DecalRoad::initPersistFields()
{
addGroup( "DecalRoad" );
addField( "material", TypeMaterialName, Offset( mMaterialName, DecalRoad ), "Material used for rendering." );
addProtectedField( "textureLength", TypeF32, Offset( mTextureLength, DecalRoad ), &DecalRoad::ptSetTextureLength, &defaultProtectedGetFn,
"The length in meters of textures mapped to the DecalRoad" );
addProtectedField( "breakAngle", TypeF32, Offset( mBreakAngle, DecalRoad ), &DecalRoad::ptSetBreakAngle, &defaultProtectedGetFn,
"Angle in degrees - DecalRoad will subdivided the spline if its curve is greater than this threshold." );
addField( "renderPriority", TypeS32, Offset( mRenderPriority, DecalRoad ),
"DecalRoad(s) are rendered in descending renderPriority order." );
endGroup( "DecalRoad" );
addGroup( "Internal" );
addProtectedField( "node", TypeString, NULL, &addNodeFromField, &emptyStringProtectedGetFn,
"Do not modify, for internal use." );
endGroup( "Internal" );
Parent::initPersistFields();
}
void GuiBitmapButtonCtrl::initPersistFields()
{
addGroup( "Bitmap" );
addProtectedField( "bitmap", TypeStringFilename, Offset( mBitmapName, GuiBitmapButtonCtrl ),
&_setBitmap, &defaultProtectedGetFn,
"Texture file to display on this button.\n"
"If useStates is false, this will be the file that renders on the control. Otherwise, this will "
"specify the default texture name to which the various state and modifier suffixes are appended "
"to find the per-state and per-modifier (if enabled) textures." );
addField( "bitmapMode", TYPEID< BitmapMode >(), Offset( mBitmapMode, GuiBitmapButtonCtrl ),
"Behavior for fitting the bitmap to the control extents.\n"
"If set to 'Stretched', the bitmap will be stretched both verticall and horizontally to fit inside "
"the control's extents.\n\n"
"If set to 'Centered', the bitmap will stay at its original resolution centered in the control's "
"rectangle (getting clipped if the control is smaller than the texture)." );
addProtectedField( "autoFitExtents", TypeBool, Offset( mAutoFitExtents, GuiBitmapButtonCtrl ),
&_setAutoFitExtents, &defaultProtectedGetFn,
"If true, the control's extents will be set to match the bitmap's extents when setting the bitmap.\n"
"The bitmap extents will always be taken from the default/normal bitmap (in case the extents of the various "
"bitmaps do not match up.)" );
addField( "useModifiers", TypeBool, Offset( mUseModifiers, GuiBitmapButtonCtrl ),
"If true, per-modifier button functionality is enabled.\n"
"@ref guibitmapbutton_modifiers" );
addField( "useStates", TypeBool, Offset( mUseStates, GuiBitmapButtonCtrl ),
"If true, per-mouse state button functionality is enabled.\n"
"Defaults to true.\n\n"
"If you do not use per-state images on this button set this to false to speed up the loading process "
"by inhibiting searches for the individual images." );
endGroup( "Bitmap" );
Parent::initPersistFields();
}
void GuiDirectoryFileListCtrl::initPersistFields()
{
addProtectedField( "filePath", TypeString, Offset( mFilePath, GuiDirectoryFileListCtrl ),
&_setFilePath, &defaultProtectedGetFn, "Path in game directory from which to list files." );
addProtectedField( "fileFilter", TypeString, Offset( mFilter, GuiDirectoryFileListCtrl ),
&_setFilter, &defaultProtectedGetFn, "Tab-delimited list of file name patterns. Only matched files will be displayed." );
Parent::initPersistFields();
}
//-----------------------------------------------------------------------------
// Persist Fields.
//-----------------------------------------------------------------------------
void FieldBrushObject::initPersistFields()
{
// Add Fields.
addProtectedField("description", TypeCaseString, Offset(mDescription, FieldBrushObject), setDescription, defaultProtectedGetFn, "");
addProtectedField("sortName", TypeString, Offset(mSortName, FieldBrushObject), setSortName, defaultProtectedGetFn, "");
// Call Parent.
Parent::initPersistFields();
}
void Portal::initPersistFields()
{
addGroup( "Zoning" );
addProtectedField( "frontSidePassable", TypeBool, Offset( mPassableSides[ FrontSide ], Portal ),
&_setFrontSidePassable, &defaultProtectedGetFn,
"Whether one can view through the front-side of the portal." );
addProtectedField( "backSidePassable", TypeBool, Offset( mPassableSides[ BackSide ], Portal ),
&_setBackSidePassable, &defaultProtectedGetFn,
"Whether one can view through the back-side of the portal." );
endGroup( "Zoning" );
Parent::initPersistFields();
}
void ProjectileData::initPersistFields()
{
addNamedField(particleEmitter, TypeParticleEmitterDataPtr, ProjectileData);
addNamedField(particleWaterEmitter, TypeParticleEmitterDataPtr, ProjectileData);
addNamedField(projectileShapeName, TypeFilename, ProjectileData);
addNamedField(scale, TypePoint3F, ProjectileData);
addNamedField(sound, TypeSFXProfilePtr, ProjectileData);
addNamedField(explosion, TypeExplosionDataPtr, ProjectileData);
addNamedField(waterExplosion, TypeExplosionDataPtr, ProjectileData);
addNamedField(splash, TypeSplashDataPtr, ProjectileData);
addNamedField(decal, TypeDecalDataPtr, ProjectileData);
addNamedField(lightDesc, TypeLightDescriptionPtr, ProjectileData );
static FRangeValidator lightRadiusValidator( 1, 20 );
static FRangeValidator velInheritFactorValidator( 0, 1 );
static FRangeValidator muzzleVelocityValidator( 0, 10000 );
addNamedField(isBallistic, TypeBool, ProjectileData);
addNamedFieldV(velInheritFactor, TypeF32, ProjectileData, &velInheritFactorValidator );
addNamedFieldV(muzzleVelocity, TypeF32, ProjectileData, &muzzleVelocityValidator );
addNamedField(impactForce, TypeF32, ProjectileData);
static IRangeValidatorScaled lifetimeValidator( TickMs, 0, Projectile::MaxLivingTicks );
static IRangeValidatorScaled armingDelayValidator( TickMs, 0, Projectile::MaxLivingTicks );
static IRangeValidatorScaled fadeDelayValidator( TickMs, 0, Projectile::MaxLivingTicks );
char message[1024];
dSprintf(message, sizeof(message), "Milliseconds, values will be adjusted to fit %d millisecond tick intervals", TickMs);
addProtectedField("lifetime", TypeS32, Offset(lifetime, ProjectileData), &setLifetime, &getScaledValue, message);
addProtectedField("armingDelay", TypeS32, Offset(armingDelay, ProjectileData), &setArmingDelay, &getScaledValue, message);
addProtectedField("fadeDelay", TypeS32, Offset(fadeDelay, ProjectileData), &setFadeDelay, &getScaledValue, message);
static FRangeValidator bounceElasticityValidator( 0, 0.999f );
static FRangeValidator bounceFrictionValidator( 0, 1 );
static FRangeValidator gravityModValidator( 0, 1 );
addNamedFieldV(bounceElasticity, TypeF32, ProjectileData, &bounceElasticityValidator );
addNamedFieldV(bounceFriction, TypeF32, ProjectileData, &bounceFrictionValidator );
addNamedFieldV(gravityMod, TypeF32, ProjectileData, &gravityModValidator );
Parent::initPersistFields();
}
void GuiRolloutCtrl::initPersistFields()
{
addGroup( "Rollout" );
addField( "caption", TypeRealString, Offset( mCaption, GuiRolloutCtrl ),
"Text label to display on the rollout header." );
addField( "margin", TypeRectI, Offset( mMargin, GuiRolloutCtrl ),
"Margin to put around child control." );
addField( "defaultHeight", TypeS32, Offset( mDefaultHeight, GuiRolloutCtrl ),
"Default height of the client area. This is used when no child control has been added to the rollout." );
addProtectedField( "expanded", TypeBool, Offset( mIsExpanded, GuiRolloutCtrl), &setExpanded, &defaultProtectedGetFn,
"The current rollout expansion state." );
addField( "clickCollapse", TypeBool, Offset( mCanCollapse, GuiRolloutCtrl ),
"Whether the rollout can be collapsed by clicking its header." );
addField( "hideHeader", TypeBool, Offset( mHideHeader, GuiRolloutCtrl ),
"Whether to render the rollout header.\n\n"
"@note If this is false, the user cannot toggle the rollout state with the mouse." );
addField( "autoCollapseSiblings", TypeBool, Offset( mAutoCollapseSiblings, GuiRolloutCtrl ),
"Whether to automatically collapse sibling rollouts.\n\n"
"If this is true, the rollout will automatically collapse all sibling rollout controls when it "
"is expanded. If this is false, the auto-collapse behavior can be triggered by CTRL (CMD on MAC) "
"clicking the rollout header. CTRL/CMD clicking also works if this is false, in which case the "
"auto-collapsing of sibling controls will be temporarily deactivated." );
endGroup( "Rollout" );
Parent::initPersistFields();
}
void ForcedMaterialMeshMgr::initPersistFields()
{
addProtectedField("material", TYPEID< Material >(), Offset(mOverrideMaterial, ForcedMaterialMeshMgr),
&_setOverrideMat, &_getOverrideMat, "Material used to draw all meshes in the render bin.");
Parent::initPersistFields();
}
void GuiTabBookCtrl::initPersistFields()
{
addGroup( "TabBook" );
addField( "tabPosition", TYPEID< TabPosition >(), Offset( mTabPosition, GuiTabBookCtrl ),
"Where to place the tab page headers." );
addField( "tabMargin", TypeS32, Offset( mTabMargin, GuiTabBookCtrl ),
"Spacing to put between individual tab page headers." );
addField( "minTabWidth", TypeS32, Offset( mMinTabWidth, GuiTabBookCtrl ),
"Minimum width allocated to a tab page header." );
addField( "tabHeight", TypeS32, Offset( mTabHeight, GuiTabBookCtrl ),
"Height of tab page headers." );
addField( "allowReorder", TypeBool, Offset( mAllowReorder, GuiTabBookCtrl ),
"Whether reordering tabs with the mouse is allowed." );
addField( "defaultPage", TypeS32, Offset( mDefaultPageNum, GuiTabBookCtrl ),
"Index of page to select on first onWake() call (-1 to disable)." );
addProtectedField( "selectedPage", TypeS32, Offset( mSelectedPageNum, GuiTabBookCtrl ),
&_setSelectedPage, &defaultProtectedGetFn,
"Index of currently selected page." );
addField( "frontTabPadding", TypeS32, Offset( mFrontTabPadding, GuiTabBookCtrl ),
"X offset of first tab page header." );
endGroup( "TabBook" );
Parent::initPersistFields();
}
void LevelInfo::initPersistFields()
{
addGroup( "Visibility" );
addField( "nearClip", TypeF32, Offset( mNearClip, LevelInfo ), "Closest distance from the camera's position to render the world." );
addField( "visibleDistance", TypeF32, Offset( mVisibleDistance, LevelInfo ), "Furthest distance from the camera's position to render the world." );
addField( "visibleGhostDistance", TypeF32, Offset( mVisibleGhostDistance, LevelInfo ), "Furthest distance from the camera's position to render players. Defaults to visibleDistance." );
addField( "decalBias", TypeF32, Offset( mDecalBias, LevelInfo ),
"NearPlane bias used when rendering Decal and DecalRoad. This should be tuned to the visibleDistance in your level." );
endGroup( "Visibility" );
addGroup( "Fog" );
addField( "fogColor", TypeColorF, Offset( mFogData.color, LevelInfo ),
"The default color for the scene fog." );
addField( "fogDensity", TypeF32, Offset( mFogData.density, LevelInfo ),
"The 0 to 1 density value for the exponential fog falloff." );
addField( "fogDensityOffset", TypeF32, Offset( mFogData.densityOffset, LevelInfo ),
"An offset from the camera in meters for moving the start of the fog effect." );
addField( "fogAtmosphereHeight", TypeF32, Offset( mFogData.atmosphereHeight, LevelInfo ),
"A height in meters for altitude fog falloff." );
endGroup( "Fog" );
addGroup( "LevelInfo" );
addField( "canvasClearColor", TypeColorI, Offset( mCanvasClearColor, LevelInfo ),
"The color used to clear the background before the scene or any GUIs are rendered." );
endGroup( "LevelInfo" );
addGroup( "Lighting" );
addField( "ambientLightBlendPhase", TypeF32, Offset( mAmbientLightBlendPhase, LevelInfo ),
"Number of seconds it takes to blend from one ambient light color to a different one." );
addField( "ambientLightBlendCurve", TypeEaseF, Offset( mAmbientLightBlendCurve, LevelInfo ),
"Interpolation curve to use for blending from one ambient light color to a different one." );
addField( "advancedLightmapSupport", TypeBool, Offset( mAdvancedLightmapSupport, LevelInfo ),
"Enable expanded support for mixing static and dynamic lighting (more costly)" );
addProtectedField("AccuTexture", TypeStringFilename, Offset(mAccuTextureName, LevelInfo),
&_setLevelAccuTexture, &defaultProtectedGetFn, "Accumulation texture.");
endGroup( "Lighting" );
addGroup( "Sound" );
addField( "soundAmbience", TypeSFXAmbienceName, Offset( mSoundAmbience, LevelInfo ), "The global ambient sound environment." );
addField( "soundDistanceModel", TypeSFXDistanceModel, Offset( mSoundDistanceModel, LevelInfo ), "The distance attenuation model to use." );
endGroup( "Sound" );
Parent::initPersistFields();
}
void AccumulationVolume::initPersistFields()
{
addProtectedField( "texture", TypeStringFilename, Offset( mTextureName, AccumulationVolume ),
&_setTexture, &defaultProtectedGetFn, "Accumulation texture." );
Parent::initPersistFields();
}
void GuiMaterialCtrl::initPersistFields()
{
addGroup( "Material" );
addProtectedField( "materialName", TypeStringFilename, Offset( mMaterialName, GuiMaterialCtrl ), &GuiMaterialCtrl::_setMaterial, &defaultProtectedGetFn, "" );
endGroup( "Material" );
Parent::initPersistFields();
}
void WaterPlane::initPersistFields()
{
addGroup( "WaterPlane" );
addProtectedField( "gridSize", TypeS32, Offset( mGridSize, WaterPlane ), &protectedSetGridSize, &defaultProtectedGetFn,
"Spacing between vertices in the WaterBlock mesh" );
addProtectedField( "gridElementSize", TypeF32, Offset( mGridElementSize, WaterPlane ), &protectedSetGridElementSize, &defaultProtectedGetFn,
"Duplicate of gridElementSize for backwards compatility");
endGroup( "WaterPlane" );
Parent::initPersistFields();
removeField( "rotation" );
removeField( "scale" );
}
void Trigger::initPersistFields()
{
addField("polyhedron", TypeTriggerPolyhedron, Offset(mTriggerPolyhedron, Trigger),
"@brief Defines a non-rectangular area for the trigger.\n\n"
"Rather than the standard rectangular bounds, this optional parameter defines a quadrilateral "
"trigger area. The quadrilateral is defined as a corner point followed by three vectors "
"representing the edges extending from the corner.\n");
addProtectedField("enterCommand", TypeCommand, Offset(mEnterCommand, Trigger), &setEnterCmd, &defaultProtectedGetFn,
"The command to execute when an object enters this trigger. Object id stored in %%obj. Maximum 1023 characters." );
addProtectedField("leaveCommand", TypeCommand, Offset(mLeaveCommand, Trigger), &setLeaveCmd, &defaultProtectedGetFn,
"The command to execute when an object leaves this trigger. Object id stored in %%obj. Maximum 1023 characters." );
addProtectedField("tickCommand", TypeCommand, Offset(mTickCommand, Trigger), &setTickCmd, &defaultProtectedGetFn,
"The command to execute while an object is inside this trigger. Maximum 1023 characters." );
Parent::initPersistFields();
}
void AIFleeComponent::initPersistFields()
{
Parent::initPersistFields();
addProtectedField("Owner", TypeSimObjectPtr, Offset(mOwner, AIFleeComponent), &defaultProtectedSetFn, &defaultProtectedGetFn, "" );
addField("weight", TypeF32, Offset(mWeight, AIFleeComponent),
"Relative weight amongst all AI movement components." );
}
void BehaviorInstance::initPersistFields()
{
addGroup("Behavior");
addField("template", TypeSimObjectName, Offset(mTemplate, BehaviorInstance), "Template this instance was created from.");
addProtectedField( "Owner", TypeSimObjectPtr, Offset(mBehaviorOwner, BehaviorInstance), &setOwner, &defaultProtectedGetFn, "Behavior component owner." );
endGroup("Behavior");
Parent::initPersistFields();
}
void BehaviorTemplate::initPersistFields()
{
addGroup("Behavior");
addField("friendlyName", TypeCaseString, Offset(mFriendlyName, BehaviorTemplate), "Human friendly name of this behavior");
addProtectedField("description", TypeCaseString, Offset(mDescription, BehaviorTemplate), &setDescription, &getDescription, "The description of this behavior.\n");
addField("behaviorType", TypeString, Offset(mBehaviorType, BehaviorTemplate), "?? Organizational keyword ??");
endGroup("Behavior");
Parent::initPersistFields();
}
void ArrayObject::initPersistFields()
{
addField( "caseSensitive", TypeBool, Offset( mCaseSensitive, ArrayObject ),
"Makes the keys and values case-sensitive.\n"
"By default, comparison of key and value strings will be case-insensitive." );
addProtectedField( "key", TypeCaseString, NULL, &_addKeyFromField, &emptyStringProtectedGetFn,
"Helper field which allows you to add new key['keyname'] = value pairs." );
Parent::initPersistFields();
}
void GuiProgressBitmapCtrl::initPersistFields()
{
addProtectedField( "bitmap", TypeFilename, Offset( mBitmapName, GuiProgressBitmapCtrl ),
_setBitmap, defaultProtectedGetFn,
"~Path to the bitmap file to use for rendering the progress bar.\n\n"
"If the profile assigned to the control already has a bitmap assigned, this property need not be "
"set in which case the bitmap from the profile is used."
);
Parent::initPersistFields();
}
void GuiFormCtrl::initPersistFields()
{
addField("caption", TypeRealString, Offset(mCaption, GuiFormCtrl));
addField("contentLibrary",TypeString, Offset(mContentLibrary, GuiFormCtrl));
addField("content", TypeString, Offset(mContent, GuiFormCtrl));
addField("movable", TypeBool, Offset(mCanMove, GuiFormCtrl));
addProtectedField( "hasMenu", TypeBool, Offset(mHasMenu, GuiFormCtrl),
&_setHasMenu, &defaultProtectedGetFn,
"" );
Parent::initPersistFields();
}
void SimComponent::initPersistFields()
{
addGroup("Component");
addProtectedField( "Template", TypeBool, Offset(mTemplate, SimComponent),
&setIsTemplate, &defaultProtectedGetFn,
"Places the object in a component set for later use in new levels." );
endGroup("Component");
// Call Parent.
Parent::initPersistFields();
}
void GuiBitmapCtrl::initPersistFields()
{
addGroup( "Bitmap" );
addProtectedField( "bitmap", TypeImageFilename, Offset( mBitmapName, GuiBitmapCtrl ),
&setBitmapName, &defaultProtectedGetFn,
"The bitmap file to display in the control." );
addField( "wrap", TypeBool, Offset( mWrap, GuiBitmapCtrl ),
"If true, the bitmap is tiled inside the control rather than stretched to fit." );
endGroup( "Bitmap" );
Parent::initPersistFields();
}
void RenderFormatToken::initPersistFields()
{
addProtectedField("format", TypeEnum, Offset(mColorFormat, RenderFormatToken),
&_setFmt, &defaultProtectedGetFn, 1, &gTextureFormatEnumTable,
"Sets the color buffer format for this token.");
addProtectedField("depthFormat", TypeEnum, Offset(mDepthFormat, RenderFormatToken),
&_setFmt, &defaultProtectedGetFn, 1, &gTextureFormatEnumTable,
"Sets the depth/stencil buffer format for this token.");
addField("copyEffect", TypeSimObjectPtr, Offset(mCopyPostEffect, RenderFormatToken),
"This PostEffect will be run when the render target is changed to the format specified "
"by this token. It is used to copy/format data into the token rendertarget");
addField("resolveEffect", TypeSimObjectPtr, Offset(mResolvePostEffect, RenderFormatToken),
"This PostEffect will be run when the render target is changed back to the format "
"active prior to this token. It is used to copy/format data from the token rendertarget to the backbuffer.");
addField("aaLevel", TypeS32, Offset(mTargetAALevel, RenderFormatToken),
"Anti-ailiasing level for the this token. 0 disables, -1 uses adapter default.");
Parent::initPersistFields();
}
void SceneObject::initPersistFields()
{
addGroup( "Transform" );
addProtectedField( "position", TypeMatrixPosition, Offset( mObjToWorld, SceneObject ),
&_setFieldPosition, &defaultProtectedGetFn,
"Object world position." );
addProtectedField( "rotation", TypeMatrixRotation, Offset( mObjToWorld, SceneObject ),
&_setFieldRotation, &defaultProtectedGetFn,
"Object world orientation." );
addProtectedField( "scale", TypePoint3F, Offset( mObjScale, SceneObject ),
&_setFieldScale, &defaultProtectedGetFn,
"Object world scale." );
endGroup( "Transform" );
addGroup( "Editing" );
addProtectedField( "isRenderEnabled", TypeBool, Offset( mObjectFlags, SceneObject ),
&_setRenderEnabled, &_getRenderEnabled,
"Controls client-side rendering of the object.\n"
"@see isRenderable()\n" );
addProtectedField( "isSelectionEnabled", TypeBool, Offset( mObjectFlags, SceneObject ),
&_setSelectionEnabled, &_getSelectionEnabled,
"Determines if the object may be selected from wihin the Tools.\n"
"@see isSelectable()\n" );
endGroup( "Editing" );
addGroup( "Mounting" );
addProtectedField( "mountPID", TypePID, Offset( mMountPID, SceneObject ), &_setMountPID, &defaultProtectedGetFn,
"@brief PersistentID of object we are mounted to.\n\n"
"Unlike the SimObjectID that is determined at run time, the PersistentID of an object is saved with the level/mission and "
"may be used to form a link between objects." );
addField( "mountNode", TypeS32, Offset( mMount.node, SceneObject ), "Node we are mounted to." );
addField( "mountPos", TypeMatrixPosition, Offset( mMount.xfm, SceneObject ), "Position we are mounted at ( object space of our mount object )." );
addField( "mountRot", TypeMatrixRotation, Offset( mMount.xfm, SceneObject ), "Rotation we are mounted at ( object space of our mount object )." );
endGroup( "Mounting" );
addGroup( "Rendering" );
addProtectedField( "paletteColors", TYPEID< ColorI >(), Offset(mPalette.colors, SceneObject), &_setPaletteColors, &defaultProtectedGetFn, Palette::NumSlots,
"@brief Dynamic object colorization RGBA values.\n\n"
"Whether and how these colors are actually used depends on the object and its materials." );
endGroup( "Rendering" );
Parent::initPersistFields();
}
void ConvexShape::initPersistFields()
{
addGroup( "Rendering" );
addField( "material", TypeMaterialName, Offset( mMaterialName, ConvexShape ), "Material used to render the ConvexShape surface." );
endGroup( "Rendering" );
addGroup( "Internal" );
addProtectedField( "surface", TypeRealString, NULL, &protectedSetSurface, &defaultProtectedGetFn,
"Do not modify, for internal use.", AbstractClassRep::FIELD_HideInInspectors );
endGroup( "Internal" );
Parent::initPersistFields();
}
void ConsoleObject::addProtectedField(const char* in_pFieldname,
const U32 in_fieldType,
const dsize_t in_fieldOffset,
AbstractClassRep::SetDataNotify in_setDataFn,
AbstractClassRep::GetDataNotify in_getDataFn,
const char* in_pFieldDocs,
U32 flags )
{
addProtectedField(
in_pFieldname,
in_fieldType,
in_fieldOffset,
in_setDataFn,
in_getDataFn,
1,
in_pFieldDocs,
flags );
}
void GuiSliderCtrl::initPersistFields()
{
addGroup( "Slider" );
addField( "range", TypePoint2F, Offset( mRange, GuiSliderCtrl ),
"Min and max values corresponding to left and right slider position." );
addField( "ticks", TypeS32, Offset( mTicks, GuiSliderCtrl ),
"Spacing between tick marks in pixels. 0=off." );
addField( "snap", TypeBool, Offset( mSnap, GuiSliderCtrl ),
"Whether to snap the slider to tick marks." );
addProtectedField( "value", TypeF32, Offset( mValue, GuiSliderCtrl ),
_setValue, defaultProtectedGetFn,
"The value corresponding to the current slider position." );
endGroup( "Slider" );
Parent::initPersistFields();
}
