Change class filtering to always use an allow list and a block list.
Change class filtering to enable allowlist all classes in a scriptpackage.
Move implementation of hybrid iterative's allow-all mode out into a separately parsed parameter.
Fix some Engine and UnrealEd classes that were not allowing EditorDomain to call Serialize on their class default object (which it needs to do to collect CustomVersions).
#rnx
#rb Zousar.Shaker
[CL 26102598 by Matt Peters in ue5-main branch]
This now subscribes to FCoreUObjectDelegates::OnObjectsReinstanced directly instead of only relying on the ARO fix-up
#preflight 63d40cce5c69f453c1319b95
#rb Francis.Hurteau, Tom.Noonan
#rnx
[CL 23899830 by jamie dale in ue5-main branch]
[FYI] Jamie.Dale, Tom.Noonan
Original CL Desc
-----------------------------------------------------------------
Attempt to catch any reinstanced objects referenced by the transaction buffer
This now subscribes to FCoreUObjectDelegates::OnObjectsReinstanced directly instead of only relying on the ARO fix-up
#preflight 63d40cce5c69f453c1319b95
#rb Francis.Hurteau, Tom.Noonan
#rnx
[CL 23899452 by jamie dale in ue5-main branch]
This now subscribes to FCoreUObjectDelegates::OnObjectsReinstanced directly instead of only relying on the ARO fix-up
#preflight 63d40cce5c69f453c1319b95
#rb Francis.Hurteau, Tom.Noonan
#rnx
[CL 23899045 by jamie dale in ue5-main branch]
This was because the dirty state of the package was cached in the object transaction for the package, so if you undid back to a state where a package was previously clean, then the package would just get marked as clean again even if the in-memory state no longer matched the file on disk.
To avoid this we now "fence" the dirty state of a package on certain events (like save or delete) so we can tell if the dirty state cached in the transaction is still valid to re-apply, or if the package just needs to be marked dirty.
This also moved the save/restore of the dirty state out of the object transaction for the package and into the transaction itself, as the package object was only transacted when it became dirty, but we need each transaction to know the cached dirty state of any packages related to objects within the current transaction. This allows any undo re-evaluate the dirty state of a package, and not just an undo where the dirty state changed in the past.
#preflight 63937432bb6fefa472ed47c8
#rb Francis.Hurteau
[CL 23475320 by jamie dale in ue5-main branch]
* Add an undo buffer barrier when the skein async checkout operation begins
* Add a delegate handler for skein checkout operation completion
* Make sure auto checkout is only active in UEFN and/or if skein is enabled
* Add UI control for turning on and off Auto-checkout/Auto-undo in Source control settings
#rb stuart.hill, brooke.hubert, zach.rammell
[FYI] wouter.burgers, manuel.lang
#preflight 637b5227f514e1ded97739a4
[CL 23220340 by marco anastasi in ue5-main branch]
# Added ability for the undo history window to add or remove undo barriers when not in PIE to facilitate testing the feature
# Fixed an issue where clearing the undo stack would result in the barriers remaining and preventing subsequent undo
#preflight 6362b7890c2e7c8f91aa7ccb
#rb [at]francis.hurteau
[CL 22937867 by brooke hubert in ue5-main branch]
In this context "newly created" means both created via NewObject but also objects that go from a dead->alive state via an undo/redo operation. Previously the latter would have produced a partial (usually empty) diff for the new object state, which put the burden of correctness on higher-level systems that were listening for changes.
Annotation diffing changed the rules about how objects might have been serialized for diffing (eg, managed components only diff some properties), so higher-level systems that are doing their own archetype diffing are now producing poor/incorrect results.
This change puts that burden onto the transaction record to handle correctly, as it is the only thing that accurately knows how to do so.
#rb Rex.Hill, Francis.Hurteau, Jason.Walter
[CL 21724446 by jamie dale in ue5-main branch]
ITransactionObjectAnnotation has two new functions; SupportsAdditionalObjectChanges to state whether the annotation type supports object diffing (default false), and ComputeAdditionalObjectChanges to actually compute the diff against another annotation (which must be of the same type).
This allows transaction annotations that entirely manage other objects (such as FActorTransactionAnnotation which manages the SCS and UCS components on an actor) to produce meaningful change information that can be passed to the PostTransacted function of the managed object (tagged with ETransactionObjectChangeCreatedBy::TransactionAnnotation).
Note: It is not safe to cache the result of a ComputeAdditionalObjectChanges outside of the current transaction, as objects managed by a transaction annotation can have volatile names. This means that the transaction annotation itself will have ComputeAdditionalObjectChanges called on it during undo/redo as well as during transaction snapshot/finalization, and means that the transaction annotation must have its own way of pairing old->new objects over time.
#preflight 63062421516bef57ffe8bafe
#rb Rex.Hill, Bart.Hawthorne, Francis.Hurteau, Jason.Walter
[CL 21572764 by robomerge in ue5-main branch]
This means that snapshotting A and then B will correctly produce a diff for A and B, rather than flipping between having data for A and having data for B
#jira
#preflight skip
#rb Elliot.Colp
#rnx
[CL 21467821 by jamie dale in ue5-main branch]
This was done as we were potentially going to serialize them as part of transaction annotations, but that is no longer the case, plus the diff snapshots are now 100% non-portable.
#preflight 62f658b1bd746abb99bbd818
[FYI] Francis.Hurteau
#rnx
#ROBOMERGE-AUTHOR: jamie.dale
#ROBOMERGE-SOURCE: CL 21355836 via CL 21358393 via CL 21358464 via CL 21358472
#ROBOMERGE-BOT: UE5 (Release-Engine-Staging -> Main) (v972-20964824)
[CL 21359941 by jamie dale in ue5-main branch]
Serialized name/object data would write the index of the name/object entry in the table, however there was no guarantee that this table order was reliable between diff snapshots (eg, adding a new name part way through an object would invalidate all subsequent references, even if they were still using the same name).
This change updates the diff writer to no longer attempt to strip out the name/object data into shared tables (which was/is an optimization for serialized objects kept within the transaction buffer), and instead write the global name index and raw object pointer instead.
Note: This change means that a diffable object snapshot is no longer portable to other instances of the editor.
#preflight 62f595561e61d1ba0e56d6ab
#rb Francis.Hurteau
#rnx
#ROBOMERGE-AUTHOR: jamie.dale
#ROBOMERGE-SOURCE: CL 21353310 via CL 21354022 via CL 21354024 via CL 21354027
#ROBOMERGE-BOT: UE5 (Release-Engine-Staging -> Main) (v972-20964824)
[CL 21354819 by jamie dale in ue5-main branch]
We can no longer use the DeltaChange for this as Ar.IsTransacting() may have added extra data in the transacted object that is important for undo/redo, but not for delta change detection. This can result in an empty delta for a change that still needs to be kept for undo/redo (eg, changes to transient object data).
#jira UE-160728
#preflight 62f5152223003b62a3679f50
#rb Francis.Hurteau
#rnx
#ROBOMERGE-AUTHOR: jamie.dale
#ROBOMERGE-SOURCE: CL 21341769 via CL 21341790 via CL 21342129 via CL 21342203
#ROBOMERGE-BOT: UE5 (Release-Engine-Staging -> Main) (v972-20964824)
[CL 21343942 by jamie dale in ue5-main branch]
This allows us more control over what goes into the diff object (eg, skipping all the internal state that Ar.IsTransacting adds), as well as allowing us to always use non-tagged property serialization (as we never need to load the diff object data back into a BP that has changed layout).
The downside of this approach is that each transacted object now needs to be serialized twice during the start and end of a transaction; once to get the object state for the transaction buffer, and once to get the object state to diff. The second set of diff data is discarded once the transaction has finalized, and any transaction snapshots still only need to serialize once (as snapshots only perform a diff).
API changes:
* Split the object info out of FTransactionSerializedObject and into FTransactionSerializedObjectInfo so that it can be re-used. This data is only really needed for a diff, but the transaction buffer also need to persist a copy for notifications.
* Split the diff only data out of FTransactionSerializedObject and into FTransactionDiffableObject.
* Split the diff serialization logic out of FSerializedObjectDataWriter and into FDiffableObjectDataWriter.
* Updated various diff APIs to work on FTransactionDiffableObject.
* Updated FObjectRecord to store FTransactionDiffableObject instances for the initial and snapshot diffable object state.
#preflight 62d5db9199514be7eb7cf04c
#rb Francis.Hurteau
#rnx
#ROBOMERGE-OWNER: jamie.dale
#ROBOMERGE-AUTHOR: jamie.dale
#ROBOMERGE-SOURCE: CL 21183943 via CL 21183948 via CL 21186529 via CL 21186547 via CL 21186567
#ROBOMERGE-BOT: UE5 (Release-Engine-Staging -> Main) (v972-20964824)
[CL 21194110 by jamie dale in ue5-main branch]
