The Undo buffer

Note There are various functions that are not included in the Undo buffer and therefore cannot be undone. This includes, for example, saving files or changing default settings.

A log is kept of everything you do in Cinema 4D and every function you call up. Corresponding information is written to a memory area - the Undo buffer - which offers the Undo and Redo functions in order to return to a previous processing state. This memory area is clearly shown in the Undo History (see below).

You can set the number of steps that can be reset at Undo Depth.

Cinema 4D distinguishes between memory-intensive actions (e.g., delete object or move points) and non-memory-intensive actions (e.g., activate object, change material). The latter can therefore be called up 30 times as often as defined in the program default settings.

If you have set the undo steps to twelve, for example, you can either include twelve delete object actions in the Undo buffer or 120 activate object actions. Of course, any other combination is also possible (e.g., delete objects six times plus select 60 objects).

Example:

You create a cube at the position 0, 0, 0, then rotate it to 0, 45, 0 and then move it to the coordinates 100, 0, 0. After the third action, moving, the Undo buffer (simplified) looks as follows:

Create object in position 0, 0, 0.
Turn object to 0, 45, 0.
Move object to position 100, 0, 0.

The current position in the buffer is at position 3, the move position. If you now use Undo, Cinema 4D looks at the previous position, cancels the current action (moving) and sets a new current position on the rotation.

The undo does the same if it is called up again. It then moves to the first position, the creation. The rotation is undone.

The trick is that the buffer is not initially changed after an undo. The Move action still exists and can be restarted with Restore.

You therefore move backwards in the Undo buffer with the Undo function and forwards with Restore.

The buffer is created dynamically, i.e., nothing is actually deleted from it, but only ever added to it. As you can imagine, this should not be taken to extremes (functions such as subdividing very quickly lead to very large objects (with regard to memory), which are also stored in the Undo buffer in addition to the scene memory). For this reason, we have set a limit to the size of the buffer. In the Preferences settings, you can define how many actions are logged in the Undo buffer (see Undo Depth).

Undo

This function undoes the last change to the scene. If you use the function several times in succession, one change after the other will be canceled.

Redo

If you have undone one editing step too many with Undos, you can use this function to have the undone step executed again automatically for you.

The number of steps that can be restored corresponds to the number of steps that can be undone (see above) and is therefore not defined separately.

Undo (Action)

This function differs from the Undo function discussed above. It only affects normal, reversible actions (such as moving). Selections are no longer taken into account in the undo steps.

Imagine that you have first enlarged an object and then selected points at ten different locations. To do this, you would have had to use the selection tool 10 times. Now you want to undo the scaling. With the normal Undo command, you would now have to execute the function 11 times (10 selections plus 1 scaling). Use the Undo (action) function instead and everything will be automated.

To be precise, the following happens:

First, the system registers whether there is a removable selection in the buffer.
If one (or several consecutive ones) is found, the function jumps back to the processing step before this selection.

Because this sounds a little more complicated than it actually is, we would like to make it clearer with two simple examples:

Let A be a normal, reversible action (such as moving) and S a reversible selection. We will now look at various states in the Undo buffer.

Example 1:

You've been working away for a while. The buffer now contains the following series of actions or selections:

A S A S A A A S S S S S

First, it was edited, then selected, edited again, etc. In the end, four successive selections were made, the last one on the right (i.e., the Current State).

If you now carry out a "normal" undo, the buffer will look like this:

A S A S A A A S S S

So there are still three final selections at the end of the buffer, one has been withdrawn.

However, if you call Undo (action only) instead, you will receive the following current buffer:

A S A S A A

All four of the last selections made were canceled, as well as the last processing step before that.

Undo history

Whereas it was previously only possible to go back or forward one step at a time with Undo and Redo, the Undo history - found in the Edit menu - now lists the last steps and you can jump to the correct step in a very targeted manner. The number of entries listed is based on Undo Depth.

In undo sequences, the most recent changes are always at the top and the oldest at the bottom.

Example

You can see a small workflow on the left:

A cube was created, scaled, duplicated, both given a Rigid Body tag, then a spring was created and both cubes linked in it.
To undo the creation of the spring, click on "Undo creation of spring". The current scene status is now displayed in the Undo History with a discreet separator - marked in red at the top.
If you now create a sphere, for example, the "later" course is deleted. The list is supplemented with the following actions at the separating line.

Other things to know about the undo process

The Undo History lists both scene changes (see Undo), as well as actions (see Undo (Action)). In addition, no distinction is made between memory-intensive and non-memory-intensive actions, as described above.
View changes of any kind will not be considered.