UDocumentation UE5.7 10.02.2026 (Source)
API documentation for Unreal Engine 5.7
InterchangeFactoryBaseNode.h
Go to the documentation of this file.
1// Copyright Epic Games, Inc. All Rights Reserved.
2
3#pragma once
4
5#include "Containers/Array.h"
6#include "Containers/UnrealString.h"
7#include "CoreMinimal.h"
8#include "HAL/Platform.h"
9#include "Nodes/InterchangeBaseNode.h"
10#include "Nodes/InterchangeBaseNodeUtilities.h"
11#include "Types/AttributeStorage.h"
12#include "UObject/Class.h"
13#include "UObject/Object.h"
14#include "UObject/ObjectMacros.h"
15#include "UObject/SoftObjectPath.h"
16#include "UObject/UObjectGlobals.h"
17
18#include "InterchangeFactoryBaseNode.generated.h"
19
20class UObject;
21struct FFrame;
22
23#define IMPLEMENT_NODE_ATTRIBUTE_DELEGATE_BY_PROPERTYNAME(AttributeName, AttributeType, ObjectType, PropertyName) \
24 bool ApplyCustom##AttributeName##ToAsset(UObject* Asset) const \
25 { \
26 return ApplyAttributeToObject<AttributeType>(Macro_Custom##AttributeName##Key.Key, Asset, PropertyName); \
27 } \
28 \
29 bool FillCustom##AttributeName##FromAsset(UObject* Asset) \
30 { \
31 return FillAttributeFromObject<AttributeType>(Macro_Custom##AttributeName##Key.Key, Asset, PropertyName); \
32 }
33
34#define IMPLEMENT_NODE_ATTRIBUTE_SETTER(NodeClassName, AttributeName, AttributeType, AssetType) \
35 FString OperationName = GetTypeName() + TEXT(".Set" #AttributeName); \
36 if(InterchangePrivateNodeBase::SetCustomAttribute<AttributeType>(*Attributes, Macro_Custom##AttributeName##Key, OperationName, AttributeValue)) \
37 { \
38 if(bAddApplyDelegate) \
39 { \
40 FName AttributeNameImpl = TEXT(""#AttributeName); \
41 AttributesAppliedThroughDelegates.AddItem(Macro_Custom##AttributeName##Key.Key); \
42 AddApplyAndFillDelegates<AttributeType>(Macro_Custom##AttributeName##Key.Key, AssetType::StaticClass(), AttributeNameImpl); \
43 } \
44 return true; \
45 } \
46 return false;
47
48/*
49 * Use this macro to implement a custom node attribute setter that will add a delegate to apply the node attribute value to any UObject derived from
50 * the specified type class. Use this macro if the type class is different from the node's GetObjectCLass().
51 *
52 * The node should derive from UInterchangeFactoryBaseNode to apply a delegate.
53 * The node needs to implement 2 functions for the attribute:
54 * - ApplyCustom##AttributeName##ToAsset(UObject*): see the UE::Interchange::FApplyAttributeToAsset delegate signature.
55 * - FillCustom##AttributeName##FromAsset(UObject*): see the UE::Interchange::FFillAttributeToAsset delegate signature.
56 */
57#define IMPLEMENT_NODE_ATTRIBUTE_SETTER_WITH_CUSTOM_DELEGATE_WITH_CUSTOM_CLASS(NodeClassName, AttributeName, AttributeType, AssetType) \
58 FString OperationName = GetTypeName() + TEXT(".Set" #AttributeName); \
59 if(InterchangePrivateNodeBase::SetCustomAttribute<AttributeType>(*Attributes, Macro_Custom##AttributeName##Key, OperationName, AttributeValue)) \
60 { \
61 if(bAddApplyDelegate) \
62 { \
63 check(NodeClassName::StaticClass()->IsChildOf<UInterchangeFactoryBaseNode>()); \
64 AttributesAppliedThroughDelegates.AddItem(Macro_Custom##AttributeName##Key.Key); \
65 UClass* AssetClass = AssetType::StaticClass(); \
66 TArray<UE::Interchange::FApplyAttributeToAsset>& Delegates = ApplyCustomAttributeDelegates.FindOrAdd(AssetClass); \
67 Delegates.Add(UE::Interchange::FApplyAttributeToAsset::CreateUObject(this, &NodeClassName::ApplyCustom##AttributeName##ToAsset)); \
68 TArray<UE::Interchange::FFillAttributeToAsset>& FillDelegates = FillCustomAttributeDelegates.FindOrAdd(AssetClass); \
69 FillDelegates.Add(UE::Interchange::FFillAttributeToAsset::CreateUObject(this, &NodeClassName::FillCustom##AttributeName##FromAsset)); \
70 } \
71 return true; \
72 } \
73 return false;
74
75/*
76 * This macro uses the factory node GetObjectClass() to register the delegate instead of receiving a TypeClass.
77 * See the documentation of IMPLEMENT_NODE_ATTRIBUTE_SETTER_WITH_CUSTOM_DELEGATE_WITH_CUSTOM_CLASS.
78 */
79#define IMPLEMENT_NODE_ATTRIBUTE_SETTER_WITH_CUSTOM_DELEGATE(NodeClassName, AttributeName, AttributeType) \
80 FString OperationName = GetTypeName() + TEXT(".Set" #AttributeName); \
81 if(InterchangePrivateNodeBase::SetCustomAttribute<AttributeType>(*Attributes, Macro_Custom##AttributeName##Key, OperationName, AttributeValue)) \
82 { \
83 if(bAddApplyDelegate) \
84 { \
85 check(NodeClassName::StaticClass()->IsChildOf<UInterchangeFactoryBaseNode>()); \
86 AttributesAppliedThroughDelegates.AddItem(Macro_Custom##AttributeName##Key.Key); \
87 TArray<UE::Interchange::FApplyAttributeToAsset>& Delegates = ApplyCustomAttributeDelegates.FindOrAdd(GetObjectClass()); \
88 Delegates.Add(UE::Interchange::FApplyAttributeToAsset::CreateUObject(this, &NodeClassName::ApplyCustom##AttributeName##ToAsset)); \
89 TArray<UE::Interchange::FFillAttributeToAsset>& FillDelegates = FillCustomAttributeDelegates.FindOrAdd(GetObjectClass()); \
90 FillDelegates.Add(UE::Interchange::FFillAttributeToAsset::CreateUObject(this, &NodeClassName::FillCustom##AttributeName##FromAsset)); \
91 } \
92 return true; \
93 } \
94 return false;
95
96
97/*
98 * This macro forces the addition of the Fill and Apply delegates on 'this'
99 * if the designated attribute has been set on the source node.
100 * Copying the arrays of delegates from the source node to 'this' is not sufficient
101 * because the delegates of the source node have a reference on the source node not 'this'.
102 * Consequently, a call to those delegates would always use the source node.
103 */
104#define COPY_NODE_DELEGATES(SourceNode, AttributeName, AttributeType, AssetType) \
105{ \
106 const UE::Interchange::FAttributeKey& AttributeKey = Macro_Custom##AttributeName##Key; \
107 FString OperationName = GetTypeName() + TEXT(".Get" #AttributeName); \
108 AttributeType AttributeValue; \
109 if(InterchangePrivateNodeBase::GetCustomAttribute<AttributeType>(*SourceNode->Attributes, AttributeKey, OperationName, AttributeValue)) \
110 { \
111 FName PropertyName = TEXT(""#AttributeName); \
112 AddApplyAndFillDelegates<AttributeType>(AttributeKey.Key, AssetType::StaticClass(), PropertyName); \
113 } \
114}
115
116#define COPY_NODE_DELEGATES_WITH_CUSTOM_DELEGATE(SourceNode, NodeClassName, AttributeName, AttributeType, AssetClass) \
117{ \
118 const UE::Interchange::FAttributeKey& AttributeKey = Macro_Custom##AttributeName##Key; \
119 FString OperationName = GetTypeName() + TEXT(".Get" #AttributeName); \
120 AttributeType AttributeValue; \
121 if(InterchangePrivateNodeBase::GetCustomAttribute<AttributeType>(*SourceNode->Attributes, AttributeKey, OperationName, AttributeValue)) \
122 { \
123 TArray<UE::Interchange::FApplyAttributeToAsset>& Delegates = ApplyCustomAttributeDelegates.FindOrAdd(AssetClass); \
124 Delegates.Add(UE::Interchange::FApplyAttributeToAsset::CreateUObject(this, &NodeClassName::ApplyCustom##AttributeName##ToAsset)); \
125 TArray<UE::Interchange::FFillAttributeToAsset>& FillDelegates = FillCustomAttributeDelegates.FindOrAdd(AssetClass); \
126 FillDelegates.Add(UE::Interchange::FFillAttributeToAsset::CreateUObject(this, &NodeClassName::FillCustom##AttributeName##FromAsset)); \
127 } \
128}
129
130#define REFILL_CUSTOM_ATTRIBUTE_APPLY_DELEGATE(AttributeName, AttributeType) \
131if(AttributesAppliedThroughDelegatesKeySet.Contains(Macro_Custom##AttributeName##Key.Key)) \
132{ \
133 AttributeType ValueData; \
134 if(GetCustom##AttributeName(ValueData)) \
135 { \
136 constexpr const bool bAddApplyDelegate = true; \
137 SetCustom##AttributeName(ValueData, bAddApplyDelegate); \
138 } \
139} \
140
141#define REFILL_CUSTOM_ATTRIBUTE_APPLY_DELEGATE_EXPLICIT(AttributeKey, Getter, Setter, AttributeType) \
142if(AttributesAppliedThroughDelegatesKeySet.Contains(AttributeKey)) \
143{ \
144 AttributeType ValueData; \
145 if(Getter(ValueData)) \
146 { \
147 constexpr const bool bAddApplyDelegate = true; \
148 Setter(ValueData, bAddApplyDelegate); \
149 } \
150}
151
152
153namespace UE::Interchange
154{
155
156 DECLARE_DELEGATE_RetVal_OneParam(bool, FApplyAttributeToAsset, UObject*);
157 DECLARE_DELEGATE_RetVal_OneParam(bool, FFillAttributeToAsset, UObject*);
158
167
168} // namespace UE::Interchange
169
170UENUM()
171enum class EReimportStrategyFlags : uint8
172{
173 //Do not apply any properties when reimporting. Simply change the source data
174 ApplyNoProperties,
175 //Always apply all properties specified by the pipeline.
176 ApplyPipelineProperties,
177 //Always apply all properties specified by the pipeline, but leave the properties that were modified in the editor since the last import.
178 ApplyEditorChangedProperties UMETA(DisplayName = "Preserve Editor Changed Properties")
179};
180
186UCLASS(BlueprintType, MinimalAPI)
187class UInterchangeFactoryBaseNode : public UInterchangeBaseNode
188{
189 GENERATED_BODY()
190
191public:
192 INTERCHANGECORE_API UInterchangeFactoryBaseNode();
193
194#if WITH_EDITOR
195 INTERCHANGECORE_API virtual FString GetKeyDisplayName(const UE::Interchange::FAttributeKey& NodeAttributeKey) const override;
196 INTERCHANGECORE_API virtual FString GetAttributeCategory(const UE::Interchange::FAttributeKey& NodeAttributeKey) const override;
197 INTERCHANGECORE_API virtual bool ShouldHideAttribute(const UE::Interchange::FAttributeKey& NodeAttributeKey) const override;
198#endif
199
204 UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
205 INTERCHANGECORE_API EReimportStrategyFlags GetReimportStrategyFlags() const;
206
211 UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
212 INTERCHANGECORE_API bool SetReimportStrategyFlags(const EReimportStrategyFlags& ReimportStrategyFlags);
213
221 UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
222 INTERCHANGECORE_API bool ShouldSkipNodeImport() const;
223
227 UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
228 INTERCHANGECORE_API bool SetSkipNodeImport();
229
233 UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
234 INTERCHANGECORE_API bool UnsetSkipNodeImport();
235
239 UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
240 INTERCHANGECORE_API virtual class UClass* GetObjectClass() const;
241
245 UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
246 INTERCHANGECORE_API bool GetCustomSubPath(FString& AttributeValue) const;
247
251 UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
252 INTERCHANGECORE_API bool SetCustomSubPath(const FString& AttributeValue);
253
257 UFUNCTION(BlueprintCallable, Category = "Interchange | Node | ActorFactory")
258 INTERCHANGECORE_API bool GetCustomLevelUid(FString& AttributeValue) const;
259
263 UFUNCTION(BlueprintCallable, Category = "Interchange | Node | ActorFactory")
264 INTERCHANGECORE_API bool SetCustomLevelUid(const FString& AttributeValue);
265
269 UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
270 INTERCHANGECORE_API int32 GetFactoryDependenciesCount() const;
271
275 UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
276 INTERCHANGECORE_API void GetFactoryDependencies(TArray<FString>& OutDependencies ) const;
277
281 UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
282 INTERCHANGECORE_API void GetFactoryDependency(const int32 Index, FString& OutDependency) const;
283
287 UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
288 INTERCHANGECORE_API bool AddFactoryDependencyUid(const FString& DependencyUid);
289
293 UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
294 INTERCHANGECORE_API bool RemoveFactoryDependencyUid(const FString& DependencyUid);
295
299 UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
300 INTERCHANGECORE_API bool GetCustomReferenceObject(FSoftObjectPath& AttributeValue) const;
301
305 UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
306 INTERCHANGECORE_API bool SetCustomReferenceObject(const FSoftObjectPath& AttributeValue);
307
308 static INTERCHANGECORE_API FString BuildFactoryNodeUid(const FString& TranslatedNodeUid);
309 static INTERCHANGECORE_API FString BuildTranslatedNodeUid(const FString& InFactoryNodeUid);
310
317 template<typename AttributeType>
318 inline void AddApplyAndFillDelegates(const FString& NodeAttributeKey, UClass* ObjectClass, const FName PropertyName);
319
327 template<typename AttributeType>
328 inline bool ApplyAttributeToObject(const FString& NodeAttributeKey, UObject* Object, const FName PropertyName) const;
329
337 template<typename AttributeType>
338 inline bool FillAttributeFromObject(const FString& NodeAttributeKey, UObject* Object, const FName PropertyName);
339
345 virtual void CopyWithObject(const UInterchangeFactoryBaseNode* SourceNode, UObject* Object)
346 {
347 // Just copy the attributes storage. Child classes will use Object in their override
348 UInterchangeBaseNode::CopyStorage(SourceNode, this);
349 }
350
356 INTERCHANGECORE_API void ApplyAllCustomAttributeToObject(UObject* Object) const;
357
358 INTERCHANGECORE_API void FillAllCustomAttributeFromObject(UObject* Object) const;
359
363 INTERCHANGECORE_API void RestoreAllCustomAttributeDelegates();
364
369 INTERCHANGECORE_API void RemoveCustomAttributesForClass(UClass* Class);
370
374 INTERCHANGECORE_API void RemoveAllCustomAttributeDelegates();
375
382 static INTERCHANGECORE_API UInterchangeFactoryBaseNode* DuplicateWithObject(const UInterchangeFactoryBaseNode* SourceNode, UObject* Object);
383
388 UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
389 INTERCHANGECORE_API bool ShouldForceNodeReimport() const;
390
394 UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
395 INTERCHANGECORE_API bool SetForceNodeReimport();
396
400 UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
401 INTERCHANGECORE_API bool UnsetForceNodeReimport();
402
407 UFUNCTION(BlueprintCallable, Category = "Interchange | Node")
408 virtual bool IsRuntimeImportAllowed() const
409 {
410 return true;
411 }
412
413protected:
417 INTERCHANGECORE_API virtual void OnRestoreAllCustomAttributeDelegates();
418
419protected:
424 UE::Interchange::TArrayAttributeHelper<FString> FactoryDependencies;
425
426 /* This array holds the delegate to apply the attribute that has to be set on an UObject. */
427 TMap<UClass*, TArray<UE::Interchange::FApplyAttributeToAsset>> ApplyCustomAttributeDelegates;
428
429 TMap<UClass*, TArray<UE::Interchange::FFillAttributeToAsset>> FillCustomAttributeDelegates;
430
431 UE::Interchange::TArrayAttributeHelper<FString> AttributesAppliedThroughDelegates;
432
433 UPROPERTY(Transient)
434 TSet<FString> AttributesAppliedThroughDelegatesKeySet;
435
436private:
437
438 const UE::Interchange::FAttributeKey Macro_CustomSubPathKey = UE::Interchange::FAttributeKey(TEXT("SubPath"));
439 const UE::Interchange::FAttributeKey Macro_CustomLevelUidKey = UE::Interchange::FAttributeKey(TEXT("LevelUid"));
440 const UE::Interchange::FAttributeKey Macro_CustomReferenceObjectKey = UE::Interchange::FAttributeKey(TEXT("ReferenceObject"));
441};
442
443template<typename AttributeType>
444inline void UInterchangeFactoryBaseNode::AddApplyAndFillDelegates(const FString& NodeAttributeKey, UClass* ObjectClass, const FName PropertyName)
445{
446 TArray<UE::Interchange::FApplyAttributeToAsset>& ApplyDelegates = ApplyCustomAttributeDelegates.FindOrAdd(ObjectClass);
447 ApplyDelegates.Add(
448 UE::Interchange::FApplyAttributeToAsset::CreateLambda(
449 [NodeAttributeKey, PropertyName, this](UObject* Asset)
450 {
451 return ApplyAttributeToObject<AttributeType>(NodeAttributeKey, Asset, PropertyName);
452 })
453 );
454
455 TArray<UE::Interchange::FFillAttributeToAsset>& FillDelegates = FillCustomAttributeDelegates.FindOrAdd(ObjectClass);
456 FillDelegates.Add(
457 UE::Interchange::FApplyAttributeToAsset::CreateLambda(
458 [NodeAttributeKey, PropertyName, this](UObject* Asset)
459 {
460 return FillAttributeFromObject<AttributeType>(NodeAttributeKey, Asset, PropertyName);
461 })
462 );
463}
464
465template<typename AttributeType>
466inline bool UInterchangeFactoryBaseNode::ApplyAttributeToObject(const FString& NodeAttributeKey, UObject* Object, const FName PropertyName) const
467{
468 if (!Object)
469 {
470 return false;
471 }
472
473 AttributeType ValueData;
474 if (GetAttribute<AttributeType>(NodeAttributeKey, ValueData))
475 {
476 TVariant<UObject*, uint8*> Container;
477 Container.Set<UObject*>(Object);
478 if (FProperty* Property = InterchangePrivateNodeBase::FindPropertyByPathChecked(Container, Object->GetClass(), PropertyName.ToString()))
479 {
480 AttributeType* PropertyValueAddress;
481 if (Container.IsType<UObject*>())
482 {
483 PropertyValueAddress = Property->ContainerPtrToValuePtr<AttributeType>(Container.Get<UObject*>());
484 }
485 else
486 {
487 PropertyValueAddress = Property->ContainerPtrToValuePtr<AttributeType>(Container.Get<uint8*>());
488 }
489
490 *PropertyValueAddress = ValueData;
491 }
492 return true;
493 }
494 return false;
495}
496
501template<>
502inline bool UInterchangeFactoryBaseNode::ApplyAttributeToObject<FString>(const FString& NodeAttributeKey, UObject* Object, const FName PropertyName) const
503{
504 if (!Object)
505 {
506 return false;
507 }
508
509 FString ValueData;
510 if (GetAttribute<FString>(NodeAttributeKey, ValueData))
511 {
512 TVariant<UObject*, uint8*> Container;
513 Container.Set<UObject*>(Object);
514 if (FProperty* Property = InterchangePrivateNodeBase::FindPropertyByPathChecked(Container, Object->GetClass(), PropertyName.ToString()))
515 {
516 FString* PropertyValueAddress;
517 if (Container.IsType<UObject*>())
518 {
519 PropertyValueAddress = Property->ContainerPtrToValuePtr<FString>(Container.Get<UObject*>());
520 }
521 else
522 {
523 PropertyValueAddress = Property->ContainerPtrToValuePtr<FString>(Container.Get<uint8*>());
524 }
525
526 if (FObjectPropertyBase* ObjectProperty = CastField<FObjectPropertyBase>(Property))
527 {
528 ObjectProperty->SetObjectPropertyValue(PropertyValueAddress, FSoftObjectPath(ValueData).TryLoad());
529 }
530 else
531 {
532 *PropertyValueAddress = ValueData;
533 }
534
535 return true;
536 }
537 }
538 return false;
539}
540
545template<>
546inline bool UInterchangeFactoryBaseNode::ApplyAttributeToObject<bool>(const FString& NodeAttributeKey, UObject* Object, const FName PropertyName) const
547{
548 if (!Object)
549 {
550 return false;
551 }
552
553 bool bValueData;
554 if (GetAttribute<bool>(NodeAttributeKey, bValueData))
555 {
556 TVariant<UObject*, uint8*> Container;
557 Container.Set<UObject*>(Object);
558 if (FProperty* Property = InterchangePrivateNodeBase::FindPropertyByPathChecked(Container, Object->GetClass(), PropertyName.ToString()))
559 {
560 bool* PropertyValueAddress;
561 if (Container.IsType<UObject*>())
562 {
563 PropertyValueAddress = Property->ContainerPtrToValuePtr<bool>(Container.Get<UObject*>());
564 }
565 else
566 {
567 PropertyValueAddress = Property->ContainerPtrToValuePtr<bool>(Container.Get<uint8*>());
568 }
569
570 // Support for bitfields
571 if (FBoolProperty* BoolProperty = CastField<FBoolProperty>(Property))
572 {
573 BoolProperty->SetPropertyValue(PropertyValueAddress, bValueData);
574 }
575 else
576 {
577 *PropertyValueAddress = bValueData;
578 }
579
580 return true;
581 }
582 }
583 return false;
584}
585
586template<typename AttributeType>
587inline bool UInterchangeFactoryBaseNode::FillAttributeFromObject(const FString& NodeAttributeKey, UObject* Object, const FName PropertyName)
588{
589 TVariant<UObject*, uint8*> Container;
590 Container.Set<UObject*>(Object);
591 if (FProperty* Property = InterchangePrivateNodeBase::FindPropertyByPathChecked(Container, Object->GetClass(), PropertyName.ToString()))
592 {
593 AttributeType* PropertyValueAddress;
594 if (Container.IsType<UObject*>())
595 {
596 PropertyValueAddress = Property->ContainerPtrToValuePtr<AttributeType>(Container.Get<UObject*>());
597 }
598 else
599 {
600 PropertyValueAddress = Property->ContainerPtrToValuePtr<AttributeType>(Container.Get<uint8*>());
601 }
602
603 // Support for bitfields
604 if (FBoolProperty* BoolProperty = CastField<FBoolProperty>(Property))
605 {
606 const bool bPropertyValue = BoolProperty->GetPropertyValue(PropertyValueAddress);
607 return SetAttribute(NodeAttributeKey, bPropertyValue);
608 }
609 else
610 {
611 return SetAttribute(NodeAttributeKey, *PropertyValueAddress);
612 }
613 }
614
615 return false;
616}
617
622template<>
623inline bool UInterchangeFactoryBaseNode::FillAttributeFromObject<FString>(const FString& NodeAttributeKey, UObject* Object, const FName PropertyName)
624{
625 TVariant<UObject*, uint8*> Container;
626 Container.Set<UObject*>(Object);
627 if (FProperty* Property = InterchangePrivateNodeBase::FindPropertyByPathChecked(Container, Object->GetClass(), PropertyName.ToString()))
628 {
629 FString* PropertyValueAddress;
630 if (Container.IsType<UObject*>())
631 {
632 PropertyValueAddress = Property->ContainerPtrToValuePtr<FString>(Container.Get<UObject*>());
633 }
634 else
635 {
636 PropertyValueAddress = Property->ContainerPtrToValuePtr<FString>(Container.Get<uint8*>());
637 }
638
639 if (FObjectPropertyBase* ObjectProperty = CastField<FObjectPropertyBase>(Property))
640 {
641 UObject* ObjectValue = ObjectProperty->GetObjectPropertyValue(PropertyValueAddress);
642 return SetAttribute(NodeAttributeKey, ObjectValue->GetPathName());
643 }
644 else
645 {
646 return SetAttribute(NodeAttributeKey, *PropertyValueAddress);
647 }
648 }
649
650 return false;
651}
652
657template<>
658inline bool UInterchangeFactoryBaseNode::FillAttributeFromObject<bool>(const FString& NodeAttributeKey, UObject* Object, const FName PropertyName)
659{
660 TVariant<UObject*, uint8*> Container;
661 Container.Set<UObject*>(Object);
662 if (FProperty* Property = InterchangePrivateNodeBase::FindPropertyByPathChecked(Container, Object->GetClass(), PropertyName.ToString()))
663 {
664 bool* PropertyValueAddress;
665 if (Container.IsType<UObject*>())
666 {
667 PropertyValueAddress = Property->ContainerPtrToValuePtr<bool>(Container.Get<UObject*>());
668 }
669 else
670 {
671 PropertyValueAddress = Property->ContainerPtrToValuePtr<bool>(Container.Get<uint8*>());
672 }
673
674 // Support for bitfields
675 if (FBoolProperty* BoolProperty = CastField<FBoolProperty>(Property))
676 {
677 const bool bPropertyValue = BoolProperty->GetPropertyValue(PropertyValueAddress);
678 return SetAttribute(NodeAttributeKey, bPropertyValue);
679 }
680 else
681 {
682 return SetAttribute(NodeAttributeKey, *PropertyValueAddress);
683 }
684 }
685
686 return false;
687}
TEXT
#define TEXT(x)
Definition Platform.h:1272
int32
FPlatformTypes::int32 int32
A 32-bit signed integer.
Definition Platform.h:1125
StaticCastSharedRef
UE_FORCEINLINE_HINT TSharedRef< CastToType, Mode > StaticCastSharedRef(TSharedRef< CastFromType, Mode > const &InSharedRef)
Definition SharedPointer.h:127
DECLARE_DELEGATE_RetVal_OneParam
#define DECLARE_DELEGATE_RetVal_OneParam(ReturnValueType, DelegateName, Param1Type)
Definition DelegateCombinations.h:54
EReimportStrategyFlags
EReimportStrategyFlags
Definition InterchangeFactoryBaseNode.h:172
UPROPERTY
#define UPROPERTY(...)
UObject definition macros.
Definition ObjectMacros.h:744
GENERATED_BODY
#define GENERATED_BODY(...)
Definition ObjectMacros.h:765
UFUNCTION
#define UFUNCTION(...)
Definition ObjectMacros.h:745
UCLASS
#define UCLASS(...)
Definition ObjectMacros.h:776
UENUM
#define UENUM(...)
Definition ObjectMacros.h:749
uint8
uint8_t uint8
Definition binka_ue_file_header.h:8
FBoolProperty
Definition UnrealType.h:2543
FName
Definition NameTypes.h:617
FObjectPropertyBase
Definition UnrealType.h:2725
FProperty
Definition UnrealType.h:174
TArray
Definition Array.h:670
TMap
Definition UnrealString.h.inl:34
TVariant
Definition TVariant.h:48
TVariant::Set
void Set(typename TIdentity< U >::Type &&Value)
Definition TVariant.h:193
UClass
Definition Class.h:3793
UE::Interchange::TArrayAttributeHelper
Definition InterchangeBaseNodeUtilities.h:22
UInterchangeBaseNode
Definition InterchangeBaseNode.h:195
UInterchangeBaseNode::SetAttribute
bool SetAttribute(const FString &NodeAttributeKey, const AttributeType &Value)
Definition InterchangeBaseNode.h:420
UInterchangeBaseNode::CopyStorage
static INTERCHANGECORE_API void CopyStorage(const UInterchangeBaseNode *SourceNode, UInterchangeBaseNode *DestinationNode)
Definition InterchangeBaseNode.cpp:604
UInterchangeFactoryBaseNode
Definition InterchangeFactoryBaseNode.h:188
UInterchangeFactoryBaseNode::FactoryDependencies
UE::Interchange::TArrayAttributeHelper< FString > FactoryDependencies
Definition InterchangeFactoryBaseNode.h:424
UInterchangeFactoryBaseNode::CopyWithObject
virtual void CopyWithObject(const UInterchangeFactoryBaseNode *SourceNode, UObject *Object)
Definition InterchangeFactoryBaseNode.h:345
UInterchangeFactoryBaseNode::AttributesAppliedThroughDelegates
UE::Interchange::TArrayAttributeHelper< FString > AttributesAppliedThroughDelegates
Definition InterchangeFactoryBaseNode.h:431
UInterchangeFactoryBaseNode::FillCustomAttributeDelegates
TMap< UClass *, TArray< UE::Interchange::FFillAttributeToAsset > > FillCustomAttributeDelegates
Definition InterchangeFactoryBaseNode.h:429
UInterchangeFactoryBaseNode::ApplyAttributeToObject
bool ApplyAttributeToObject(const FString &NodeAttributeKey, UObject *Object, const FName PropertyName) const
Definition InterchangeFactoryBaseNode.h:466
UInterchangeFactoryBaseNode::ApplyCustomAttributeDelegates
TMap< UClass *, TArray< UE::Interchange::FApplyAttributeToAsset > > ApplyCustomAttributeDelegates
Definition InterchangeFactoryBaseNode.h:427
UInterchangeFactoryBaseNode::FillAttributeFromObject
bool FillAttributeFromObject(const FString &NodeAttributeKey, UObject *Object, const FName PropertyName)
Definition InterchangeFactoryBaseNode.h:587
UObjectBaseUtility::GetPathName
COREUOBJECT_API FString GetPathName(const UObject *StopOuter=NULL) const
Definition UObjectBaseUtility.cpp:38
UObject
Definition Object.h:95
InterchangePrivateNodeBase::FindPropertyByPathChecked
INTERCHANGECORE_API FProperty * FindPropertyByPathChecked(TVariant< UObject *, uint8 * > &Container, UStruct *Outer, FStringView PropertyPath)
Definition InterchangeBaseNode.cpp:609
UE::Interchange
Definition InterchangeHelper.cpp:9
UE
Definition AdvancedWidgetsModule.cpp:13
Index
U16 Index
Definition radfft.cpp:71
FAttributeKey
Definition AttributeCurve.h:23
FFrame
Definition Stack.h:114
FSoftObjectPath
Definition SoftObjectPath.h:56
UE::Interchange::FAttributeKey
Definition AttributeStorage.h:67
UE::Interchange::FBaseNodeStaticData
Definition InterchangeBaseNode.h:157
UE::Interchange::FFactoryBaseNodeStaticData
Definition InterchangeFactoryBaseNode.h:160
UE::Interchange::FFactoryBaseNodeStaticData::ReimportStrategyFlagsKey
static INTERCHANGECORE_API const FAttributeKey & ReimportStrategyFlagsKey()
Definition InterchangeFactoryBaseNode.cpp:30
UE::Interchange::FFactoryBaseNodeStaticData::SkipNodeImportKey
static INTERCHANGECORE_API const FAttributeKey & SkipNodeImportKey()
Definition InterchangeFactoryBaseNode.cpp:36
UE::Interchange::FFactoryBaseNodeStaticData::ForceNodeReimportKey
static INTERCHANGECORE_API const FAttributeKey & ForceNodeReimportKey()
Definition InterchangeFactoryBaseNode.cpp:42
UE::Interchange::FFactoryBaseNodeStaticData::AttributesAppliedThroughDelegatesBaseKey
static INTERCHANGECORE_API const FString & AttributesAppliedThroughDelegatesBaseKey()
Definition InterchangeFactoryBaseNode.cpp:24
UE::Interchange::FFactoryBaseNodeStaticData::FactoryDependenciesBaseKey
static INTERCHANGECORE_API const FString & FactoryDependenciesBaseKey()
Definition InterchangeFactoryBaseNode.cpp:18