- TableRowStyle for Sequencer which is a combination of the alternative row style and the show parent style - Alternating rows have different tints, parents have different tints.
- Make sure top level rows also report as a parent row
- Rows that have keys or sections selected also report as highlighted
#rb Andrew.Rodham
#jira UE-200166
[CL 30187311 by max chen in ue5-main branch]
The Binding Lifetime track is an optional track that can be added to any object binding. It allows the user to set time range(s) for when the object in question will be bound by Sequencer. Outside of those ranges, the object will be released, and any tracks underneath it will restore state/keep state as set.
Currently this track works for both spawnables and possessables. This track is a precursor to other binding types coming to Sequencer, and in the future this track will allow the user to trigger events as part of the binding activation/deactivation so that changes like AI control for example can be set when binding/unbinding NPC characters or player characters.
As part of this change, it was necessary to clean up some of the sequencer UI color settings on labels, as well as a few changes to the layer bar UI to facilitate a hatch overlay for the sections of the binding tracks that are in a deactivated area.
[REVIEW] [at]ue-sequencer
#jira UE-200088, UE-199857, UE-199299
#rb ludovic.chabant
[CL 29636485 by david bromberg in ue5-main branch]
+ Added a new row type for outliner trees that sets the background color once for the whole row. Previously this logic was implemented by each widget within the row (now each column widget, and the outliner view widget), which meant we re-ran the exact same logic (that was copied around) for background color computation multiple times per row. We now only do this once for the whole row.
+ Added a ModelID to all MVVM models. This is just a non-persistent serial uint32 unique to the instance and can be used for more efficient and stable keys than using the instance ptr.
+ SharedData is now a view model so it can support arbitrary extension and casting. This enables us to:
+ Add a new hierarchical cache extension that is easily accessible from any widget using GetSharedData()->CastThis<FOutlinerCacheExtension>()
+ Hierarchical Cache will perform a single pass on the entire MVVM hierarchy and allow clients to compute cached flags.
+ We have a separate cache for each of mute, solo and lock states that includes whether the item is set directly, and also whether it has settable children, and is implicitly set by a parent or child.
+ Added a dynamic extension iterator that allows anyone to iterate and filter the currently active dynamic extensions.
+ Moved Mute and Solo logic into the actual mute / solo extensions, rather than it being implemented in the NodeTree
+ Fixed header coloration for collapsed outliner rows that had selected keys within them. The logic here was incorrect and looked like an error in porting the code. It is now correct (and more efficient).
- Only folders, objects, tracks and track rows now implement mute/solo. Channels and categories were never supported, and now no longer show as such on the UI.
- Deleted the pre-existing XYZEditorExtension classes since they have all been ported to these new caches (the code is largely the same)
#jira UE-193500
#rb Max.Chen
[CL 27669850 by andrew rodham in ue5-main branch]
As part of this, change display name tooltips on tracks back to using a function rather than a saved value so they can be dynamically specified. This needed Sequencer and ObjectBindingID passed to the function for context. This was only very recently changed to use saved values, so this shouldn't cause issues.
#jira UE-192507
[REVIEW] [at]ue-sequencer
[CL 27595620 by david bromberg in ue5-main branch]
This corrects the event only being broadcast for the SetHotspot call from CL 24179637.
#jira UE-191858
#rb Max.Chen
[CL 26818509 by andrew rodham in ue5-main branch]
Implementations for the pin, mute, lock, and solo outliner columns to be displayed in the SOutlinerView of Sequencer. Each outliner column widget implements click and drag functionality. Outliner column visibility is saved per-sequencer and per-user. Default column visibility and order can be saved and restored in BaseEditorPerProjectUserSettings.ini.
#jira UE-105291
#rb max.chen
[CL 26656030 by john manard in ue5-main branch]
These editor extensions are used by outliner column implementations to query and modify pin, mute, lock, and solo.
#jira UE-105291
#rb max.chen
[CL 26520650 by john manard in ue5-main branch]
The tempoarary structure used by duplication has no owner, so doesn't need to report changes
#rb none
#jira UE-188234
[CL 25879219 by andrew rodham in ue5-main branch]
- Draw easing handles as rounded triangles sized to match the grip size, instead of the previous bitmap.
- Easing handles are bigger, with bigger hit-testing area.
- Expose key size through the section interface in addition to grip size
- Fix bug where small sections can result in negative time-to-pixel conversion
#jira UE-171407
#rb max.chen
#preflight 6476202b4b1ead7c7f1db4e0
[CL 25694826 by ludovic chabant in ue5-main branch]
The aim of this work is to improve overall CPU cost in 3 ways:
- to reduce the per-frame overhead of running ECS tasks
- to decrease latency between useful gamethread work being able to run
- to increase thread ultilization where many cores are available
In both single-threaded and multi-threaded mode this is showing a wall-clock speed improvement of ~25%, upon which other optimizations can now be made.
Previously, the Dispatch_ methods would construct tasks and filters for their work every frame. Tasks dispatched by downstream systems that were added as implicit dependencies would always depend on all the work of their upstream systems, even if they didn't necessarily need to be (for example, float properties would need to wait for *all* float channels to be evaluated and blended before they could be applied, even ones that only applied to transform properties).
The new approach introduces a new system phase (ESystemPhase::Scheduling) which is only run as part of the post-instantiation. This phase invokes a new method (OnSchedulePersistentTasks) which allows systems to define the task-structure for the current state of the ECS. Tasks defined here are stored inside the scheduler, and live for the duration of the instantiation - if the structure of the entity manager materially changes, the task graph is re-constructed.
Entity task builders are still used in this new method, but can only call Schedule_ and Fork_ functions for running tasks. These methods define serial and parallel behavior respectively that is to be run across the ECS (as should already be familiar). Crucially, each relevant entity allocation now gets its own task - the filter is run when the task graph is constructed, and a new task is created for each match. This allows us to interleave and/or distribute tasks across as many cores as possible, as soon as prerequisites are completed.
Tasks may also 'prelock' their component data - doing so will cache the location of the component data for each task (using a new type, TRelativePtr) so that it doesn't have to go hunting for component headers when the task is run.
Implementation details:
IMovieSceneTaskScheduler exists as the public front-end to the new routines, but allows us to keep all the implementation details private.
Tasks can be in one of two states: a single task can have multiple prerequisites and subsequents, a parent task can have many children which must be complete in order for the parent to be considered complete. This is used for depending on the results of forked and serial tasks that may be spawned multiple times.
When constructing the graph, we keep track of the read and write dependencies for each component type within each allocation. When a task reads from a component it must first depend on any tasks that write to the same component on the same allocation. When a task writes to a component it must depend on all upstream read and write dependencies for that component, on that allocation.
Moved TSparseBitSet to UE::MovieScene so I can use it for task dependencies
Introduced TRelativePtr which allows storage of pointers relative to another pointer using a smaller type than a raw ptr would, and isn't invalidated like a raw ptr would be if is pointing to an element in a dynamic array.
This is used for our prelocked component data, but may have uses elsewhere. Note that this is not a TRelativePtr that is relative to 'this' like some other relative pointer implementations (though one could easily be written that uses this implementation if necessary.
#rb Ludovic.Chabant, Max.Chen
#preflight 646e782e64351d76f3c508a2
[CL 25644373 by max chen in ue5-main branch]
