Even if you've used FlatRedBall for a while you may not be familiar with exactly what a "manually updated" object is. The reason for this is because the option to make things manually updated exists almost exclusively for performance reasons. Technically one might want to manually update objects to achieve custom behavior as well, but generally this is not encouraged because it can lead to bugs and often this type of implementation duplicates functionality already present in automatically updated objects. In short, you can designate objects as manually updated to make your game run faster, and that's usually the only reason this is done.
To answer the question of what a manually updated object is, let's look at a very common piece of code:
If you've used FlatRedBall you probably know that the code above will create a Sprite, then start the Sprite's movement to the right at 5 units per second. As mentioned in one of the introductory tutorials, the Velocity property changes the Position property based off of elapsed time. This is done "automatically". This "automatic" application of velocity is what it means to be "automatically updated". So, then you might be guessing that something which is manually updated does not have Velocity applied to it every frame - and if so you're right! If an object is manually updated, then it means that the FlatRedBall Engine is not performing every-frame automatic updates on it.
The following is a list of properties which are applied for automatically updated objects. Not all properties apply to every automatically updated object. For example, the ScaleXVelocity property doesn't apply to Scale on the PositionedObject class because the PositionedObject class doesn't have the ScaleX or ScaleXVelocity properties. However, looking below can give you an idea of what kind of things are done for you by the engine:
So, if you have a group of objects which do not have any of the above properties then that group of objects is a good candidate for being made manually updated. That is, an object can safely be made manually updated if it doesn't have:
Movement
Color rate changes
Attachments
Scale velocities
Animations
Instructions
The answer is "it depends". It depends on how much of your game time is actually spent on updates. Converting to manually updated helps the most when your game has a large number of objects (such as Sprites or PositionedModels) which are going to be static - such as part of a level. It's common to have games which have hundreds or even thousands of such objects - most of which aren't even on screen. In these situations the engine may be spending a considerable amount of time updating these objects unnecessarily. Grabbing a reference to these objects (perhaps through some naming convention if using Scenes) and converting them to be manually updated can greatly improve performance. The process is fairly straight-forward so if you suspect that you may be experiencing update-related performance issues, give it a try. For an example of how this works in a very simple scenario, see the SpriteManager's AddManualSprite wiki entry.
Property that modifies
Modified property
Notes
Velocity
Position
Acceleration
Velocity/Position
Position
If KeepTrackOfReal is true.
Position/RealVelocity
If KeepTrackOfReal is true.
RotationXVelocity/RotationYVelocity/ RotationZVelocity
RotationX/RotationY/RotationZ RotationMatrix
Drag
Velocity
RelativeVelocity
RelativePosition
RelativeAcceleration
RelativeVelocity/RelativePosition
RelativeRotationXVelocity RelativeRotationYVelocity RelativeRotationZVelocity
RelativeRotationX/RelativeRotationY/ RelativeRotationZ/ RelativeRotationMatrix
Relative values
Matching absolute values
If Parent is not null.
AnimationSpeed/CurrentChain
CurrentChainIndex/Texture/Texture coordinates
ScaleXVelocity/ScaleYVelocity
ScaleX/ScaleY
Instructions
Potentially anything
The engine calls Instructions on any IInstructable that it manages.
RedRate/GreenRate/BlueRate/ AlphaRate
Red/Green/Blue/Alpha