- Added Context branching support (up to 64 elements)
- Added TParam<Type> operator [] and Opertator Type(), so we can operate directly with the TParams (this is used instead of the Kernel::run, which is harder to debug and deal with)
- Fixed batches and passing a single element to a Context that expects N elements (no more memory stomping)
- Added new ways to obtain a TParam from the Context (GetParamPtr, GetParamAs, GetParameter with TOptional). Also added a GetResultAs<Type>, to ease working with the parameters
- Fixed GetDataSafe to support containers (with Num() and GetData)
- Added NumElements to FParam (indicates the number of elements that the Data holds for this parameter)
- Updated FParam CanAssignWith to allow copy with less restrictions if the target param is empty / unasigned
- Added more constructors to TWrapParam, one with explicit NumElements and other with an ArrayView
- Added more constructors to TParam, with explicit NumElements
- Added EngineTest for DataInterface with a example at Animation.DataInterfaces.XXXXXX
- Prototype of parameter storage using arenas : Context requests the size of the passed paramters and copies the ones selected by the user to be transfered
- Prototype of stack like parameter storage, which allows storing small values directly into the Data pointer of FParam struct (pending see if it can be done constexpr, now is checked at runtime)
@rb @thomas.sarkanen @nicholas.frechette
#jira none
#preflight 635bbe469c65b7958634b506
#preflight 635bc4cd944463bad4a4b63b
[CL 22827097 by jaime cifuentes in ue5-main branch]
In an experimental plugin based on Data Interfaces system
#rb Thomas.Sarkanen
#preflight 6282c297cf7e4667a9d38ff2
[CL 20233851 by Keith Yerex in ue5-main branch]
Data interfaces are designed to be the basis for a functional, compositional framework, allowing loose bindings (a typed return value) between functional units (data interfaces). They incorporate the following main features:
- Simple call to 'get a value' from a data interface.
- Most communication is done via the UE::DataInterface::FContext, which handles data management.
- Type-erased values (UE::DataInterface::FParam) for results, parameters and state. These can be promoted to typed values (UE::DataInterface::TParam<T>) with runtime validation.
- 'Hidden state', allocated on-demand via a context, to support functional units that require statefulness. State is allocated according to the calling context, currently a hash of the 'callstack' and call site, so subsequent calls to the same data interface can reuse state.
- Batch processing of multiple state representations at once (e.g. processing multiple characters at one), via a chunked allocation strategy.
Also includes data interface graphs - a proof-of-concept implementation using RigVM to construct scripted data interface logic. This is still very early!
Still lots to do:
- Removal of typed interfaces (e.g. IDataInterface_Float)
- Validation of hidden state approach on a wider scale
- Validation of kernel processing approach
- Chunked branching (probably via a masking strategy) so branches can be handled within chunks
- Reworked type system incorporating type promotion/conversion
- UI work to allow for mixing instanced sub-objects and asset references with using TScriptInterface<IDataInterface>
- Expansion or RigVM usage and a ton of UI/UX work to get graph editing up to scratch
- Many many more things
#preflight 625e86873e0f6f80ada98290
[CL 19806109 by Thomas Sarkanen in ue5-main branch]
