izzy/UnrealEngineUWP
0
0
Fork 0
mirror of https://github.com/izzy2lost/UnrealEngineUWP.git synced 2026-03-26 18:15:20 -07:00
Code Issues Packages Projects Releases Wiki Activity
Files
6520c809a95e8823c08d9fe9ed6306f7dedfebdd
UnrealEngineUWP/Engine/Plugins/Experimental/DataInterfaceGraph/Source/DataInterfaceGraphUncookedOnly/Private/DataInterfaceGraph_EdGraph.cpp

23 lines
825 B
C++
Raw Normal View History

Initial prototype of data interfaces and data interface graphs 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]
2022-04-19 06:28:48 -04:00
// Copyright Epic Games, Inc. All Rights Reserved.
#include "DataInterfaceGraph_EdGraph.h"
#include "DataInterfaceGraph_EditorData.h"
#include "DataInterfaceUncookedOnlyUtils.h"
void UDataInterfaceGraph_EdGraph::Initialize(UDataInterfaceGraph_EditorData* InEditorData)
{
InEditorData->ModifiedEvent.RemoveAll(this);
InEditorData->ModifiedEvent.AddUObject(this, &UDataInterfaceGraph_EdGraph::HandleModifiedEvent);
InEditorData->VMCompiledEvent.RemoveAll(this);
InEditorData->VMCompiledEvent.AddUObject(this, &UDataInterfaceGraph_EdGraph::HandleVMCompiledEvent);
}
Control Rig: backend work for support for multi graph #rb benoit.gadreau #jira UE-153497 #preflight https://horde.devtools.epicgames.com/job/6294be4e2e34c2e487b13394 [CL 20434781 by Helge Mathee in ue5-main branch]
2022-05-31 04:27:20 -04:00
FRigVMClient* UDataInterfaceGraph_EdGraph::GetRigVMClient() const
Initial prototype of data interfaces and data interface graphs 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]
2022-04-19 06:28:48 -04:00
{
if (const UDataInterfaceGraph_EditorData* EditorData = GetTypedOuter<UDataInterfaceGraph_EditorData>())
{
Control Rig: backend work for support for multi graph #rb benoit.gadreau #jira UE-153497 #preflight https://horde.devtools.epicgames.com/job/6294be4e2e34c2e487b13394 [CL 20434781 by Helge Mathee in ue5-main branch]
2022-05-31 04:27:20 -04:00
return (FRigVMClient*)EditorData->GetRigVMClient();
Initial prototype of data interfaces and data interface graphs 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]
2022-04-19 06:28:48 -04:00
}
return nullptr;
}
Reference in New Issue Copy Permalink