Engine/Plugins/Experimental/DataInterfaceGraph/Source/DataInterfaceGraphUncookedOnly/Internal/DataInterfaceGraph_EdGraph.h

// Copyright Epic Games, Inc. All Rights Reserved.

#pragma once

#include "CoreMinimal.h"
#include "Graph/ControlRigGraph.h"
#include "DataInterfaceGraph_EdGraph.generated.h"

class UDataInterfaceGraph_EditorData;

namespace UE::DataInterfaceUncookedOnly
{
struct FUtils;
}

UCLASS(MinimalAPI)
class UDataInterfaceGraph_EdGraph : public UControlRigGraph
{
	GENERATED_BODY()

	friend class UDataInterfaceGraph_EditorData;

	// UControlRigGraph interface
	virtual FRigVMClient* GetRigVMClient() const override;
	
	void Initialize(UDataInterfaceGraph_EditorData* InEditorData);
};
-												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.
 								#pragma once
 								#include "CoreMinimal.h"
 								#include "Graph/ControlRigGraph.h"
 								#include "DataInterfaceGraph_EdGraph.generated.h"
 								class UDataInterfaceGraph_EditorData;
 								namespace UE::DataInterfaceUncookedOnly
 								{
 								struct FUtils;
 								}
 								UCLASS(MinimalAPI)
 								class UDataInterfaceGraph_EdGraph : public UControlRigGraph
 								{
 									GENERATED_BODY()
 									friend class UDataInterfaceGraph_EditorData;
 									// UControlRigGraph interface
-												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
+									virtual FRigVMClient* GetRigVMClient() const override;
-												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
 									void Initialize(UDataInterfaceGraph_EditorData* InEditorData);
 								};