UE4 反射 学习笔记

已于 2023-02-03 10:15:48 修改
阅读量1k 收藏 5
点赞数 1
CC 4.0 BY-SA版权
文章标签： ue4 学习
于 2023-01-16 17:30:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qqQQqsadfj/article/details/128705004

想让类具有反射机制，必须要有这四个要素：

1、generated.h文件

2、UCLASS()宏

3、继承自UObject

4、GENERATED_BODY()

void ABlurCharacter::BeginPlay()
{
	Super::BeginPlay();

	ABlurCharacter *BlurCharacter = NewObject<ABlurCharacter>();
	UClass *BlurCharacterClass = BlurCharacter->GetClass();
	FName BlurCharacterName = BlurCharacterClass->GetFName();

	GEngine->AddOnScreenDebugMessage(-1, 10.f ,FColor::Red, *BlurCharacterName.ToString());
}

这样就将类名给输出出来了 

for(UProperty *Per = BlurCharacterClass->PropertyLink; Per; Per = Per->PropertyLinkNext)
	{
		if(Per->GetCPPType() == TEXT("FString"))
		{
			UStrProperty *Str = Cast<UStrProperty>(Per); //转化为Str类型的属性
			void *Addr = Str->ContainerPtrToValuePtr<void>(BlurCharacter);  //从容器信息转变成具体值
			GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Yellow, Per->GetName() + TEXT(" ------ ") + Per->GetCPPType() +
				TEXT(" ------ ") + Str->GetPropertyValue(Addr));
            Str->SetPropertyValue(Addr, "AfterModified");
			GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Yellow, Per->GetName() + TEXT(" ------ ") + Per->GetCPPType() +
				TEXT(" ------ ") + Str->GetPropertyValue(Addr));
		}
	}
UPROPERTY()
	FString Hello = "Hello World";

获取类中FString类型的值、类型、和名称，根据代码可以看出，存储变量的数据结构是一个链表，注意，变量一定要用UPROPERTY()给包裹，不然不会将变量信息反射到链表，更不可能存取这些信息

for(TFieldIterator<UFunction> Iter(BlurCharacterClass); Iter; ++Iter)
	{
		GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Blue, Iter->GetName());
		for(TFieldIterator<UProperty> Iter1(*Iter); Iter1; ++Iter1)
		{
			GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Black, Iter1->GetName() + TEXT(" ------ ") + Iter1->GetCPPType());
		}
	}

同理，自己写的函数也必须加入UFUNCTION()

void ABeginInvokeGameModeBase::BeginPlay() {
	Super::BeginPlay();

	AAFloorSwitch* FloorSwitch = NewObject<AAFloorSwitch>();

	UClass* Father = FloorSwitch->GetClass()->GetSuperClass();
	FString Name = Father->GetName();
	GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Red, Name);
}
UCLASS()
class MYCTEST_API AAFloorSwitch : public AActor
{
	GENERATED_BODY()
	
public:	
	// Sets default values for this actor's properties
	AAFloorSwitch();
}

在GameMode进行获取父类，在Actor内获取被隐藏

判断一个类是否是另一个类的父类

查找一个类的所有子类，第三个参数是找是否找子类的类，是否递归去找 

AAFloorSwitch* swithc = NewObject<AAFloorSwitch>(this, FName("Tiger"));
	TArray<UObject*>	Res;
	GetObjectsOfClass(StaticClass(), Res, false);
	for (auto Actor : Res) {
		GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Yellow, Actor->GetName());
	}

GetObjectsOfClass()：去查找实例化出来的变量的个数

UClass *FoundClass = FindObject<UClass>(ANY_PACKAGE, *FString("ABlurCharacter"), true);
if(FoundClass->IsValidLowLevel())
{
   GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Black, FoundClass->GetName());
}

通过名字去查找类名

UEnum *FoundEnum = FindObject<UEnum>(ANY_PACKAGE, *FString("EMyEnum"), true);
if(FoundEnum->IsValidLowLevel())
{
	GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Orange, FoundEnum->GetName());
}
UENUM()
enum class EMyEnum : uint8
{
	ONE,
	TWO,
	THREE
};

通过名字查找枚举

ANY_PACKAGE是代表在每一文件夹下去查找是否有这个名字的相关值

UEnum *FoundEnum = FindObject<UEnum>(ANY_PACKAGE, *FString("EMyEnum"), true);
		if(FoundEnum->IsValidLowLevel())
		{
			//GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Orange, FoundEnum->GetName());
			for(int32 Index = 0; Index < FoundEnum->NumEnums(); Index++)
			{
				FString FoundEnumChild = FoundEnum->GetNameStringByIndex(Index);
				GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Orange, FoundEnumChild);
			}
		}
UENUM()
enum class EMyEnum : uint8
{
	ONE,
	TWO,
	THREE
};

通过枚举获取枚举内所有属性名字，EMyEnum_MAX其实是用于统计枚举内最大数值的，源代码是这么写的：

int64 UEnum::GetMaxEnumValue() const
{
	int32 NamesNum = Names.Num();
	if (NamesNum == 0)
	{
		return 0;
	}

	int64 MaxValue = Names[0].Value;
	for (int32 i = 0; i < NamesNum; ++i)
	{
		int64 CurrentValue = Names[i].Value;
		if (CurrentValue > MaxValue)
		{
			MaxValue = CurrentValue;
		}
	}

	return MaxValue;
}

如何输出这个值呢：

UEnum *FoundEnum = FindObject<UEnum>(ANY_PACKAGE, *FString("EMyEnum"), true);
if(FoundEnum->IsValidLowLevel())
	{
		GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Orange, FString::SanitizeFloat(FoundEnum->GetMaxEnumValue()));
	}

UBlueprint *BlueprintClass = FindObject<UBlueprint>(ANY_PACKAGE, *FString("BP_MainWidget"));
if(BlueprintClass->IsValidLowLevel())
{
	GEngine->AddOnScreenDebugMessage(-1, 10.f ,FColor::Red, BlueprintClass->GetName());
}

如何通过蓝图名称找到蓝图类

UBlueprint *BlueprintClass = FindObject<UBlueprint>(ANY_PACKAGE, *FString("BP_MainWidget"));
	if(BlueprintClass->IsValidLowLevel())
	{
		GEngine->AddOnScreenDebugMessage(-1, 10.f ,FColor::Red, BlueprintClass->GetName());
		if(BlueprintClass->IsNative())
		{
			GEngine->AddOnScreenDebugMessage(-1, 10.f ,FColor::Red, TEXT("YES"));
		}else
		{
			GEngine->AddOnScreenDebugMessage(-1, 10.f ,FColor::Red, TEXT("NO"));
		}
	}

判断此类是蓝图类还是C++类，Native就是C++类

ABlurCharacter *BlurCharacter = NewObject<ABlurCharacter>();
UClass *BlurCharacterClass = BlurCharacter->GetClass();
for(UProperty *Per = BlurCharacterClass->PropertyLink; Per; Per = Per->PropertyLinkNext)
{
	if(Per->GetCPPType() == TEXT("FString"))
	{
		UStrProperty *Str = Cast<UStrProperty>(Per);
		FString CategoryStr = Str->GetMetaData(TEXT("Category"));
        GEngine->AddOnScreenDebugMessage(-1, 10.f ,FColor::Red, CategoryStr);
	}
}
UPROPERTY(EditAnywhere, Category = "Hello")
	FString Hello = "Hello World";

获取元数据信息

ABlurCharacter *BlurCharacter = NewObject<ABlurCharacter>();
UClass *BlurCharacterClass = BlurCharacter->GetClass();
for(TFieldIterator<UFunction> Iter(BlurCharacterClass); Iter; ++Iter)
	{
		uint32 Flags = Iter->FunctionFlags;
		if(Iter->GetName() == TEXT("GetMousePixel"))	
            GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Blue, FString::FromInt(Flags));	
	}
UFUNCTION(BlueprintCallable)
	FColor GetMousePixel();

 

查找到数值为75629569，那么从第一位开始看为9，只能由1和8组成，所以兼备FUNC_Final和FUNC_BlueprintCosmetic的属性，即该方法为Final方法，此方法不能被继承，且该方法不能被服务端调用

再看第二位60只能由//FUNC_与FUNC_Net组成，第一个无用，没有功能，第二个该方法可被网络复制

我们直接看第七位，为5，只能由FUNC_NetClient与FUNC_BlueprintCallable组成，第一个为该函数可在客户端进行执行，第二个就是经常用到的BlueprintCallable了，如上方代码所对应

其它位数都是依次类推

enum EFunctionFlags
{
	// Function flags.
	FUNC_Final				= 0x00000001,	// Function is final (prebindable, non-overridable function).
	FUNC_RequiredAPI			= 0x00000002,	// Indicates this function is DLL exported/imported.
	FUNC_BlueprintAuthorityOnly= 0x00000004,   // Function will only run if the object has network authority
	FUNC_BlueprintCosmetic	= 0x00000008,   // Function is cosmetic in nature and should not be invoked on dedicated servers
	// FUNC_				= 0x00000010,   // unused.
	// FUNC_				= 0x00000020,   // unused.
	FUNC_Net				= 0x00000040,   // Function is network-replicated.
	FUNC_NetReliable		= 0x00000080,   // Function should be sent reliably on the network.
	FUNC_NetRequest			= 0x00000100,	// Function is sent to a net service
	FUNC_Exec				= 0x00000200,	// Executable from command line.
	FUNC_Native				= 0x00000400,	// Native function.
	FUNC_Event				= 0x00000800,   // Event function.
	FUNC_NetResponse		= 0x00001000,   // Function response from a net service
	FUNC_Static				= 0x00002000,   // Static function.
	FUNC_NetMulticast		= 0x00004000,	// Function is networked multicast Server -> All Clients
	// FUNC_				= 0x00008000,   // unused.
	FUNC_MulticastDelegate	= 0x00010000,	// Function is a multi-cast delegate signature (also requires FUNC_Delegate to be set!)
	FUNC_Public				= 0x00020000,	// Function is accessible in all classes (if overridden, parameters must remain unchanged).
	FUNC_Private			= 0x00040000,	// Function is accessible only in the class it is defined in (cannot be overridden, but function name may be reused in subclasses.  IOW: if overridden, parameters don't need to match, and Super.Func() cannot be accessed since it's private.)
	FUNC_Protected			= 0x00080000,	// Function is accessible only in the class it is defined in and subclasses (if overridden, parameters much remain unchanged).
	FUNC_Delegate			= 0x00100000,	// Function is delegate signature (either single-cast or multi-cast, depending on whether FUNC_MulticastDelegate is set.)
	FUNC_NetServer			= 0x00200000,	// Function is executed on servers (set by replication code if passes check)
	FUNC_HasOutParms		= 0x00400000,	// function has out (pass by reference) parameters
	FUNC_HasDefaults		= 0x00800000,	// function has structs that contain defaults
	FUNC_NetClient			= 0x01000000,	// function is executed on clients
	FUNC_DLLImport			= 0x02000000,	// function is imported from a DLL
	FUNC_BlueprintCallable	= 0x04000000,	// function can be called from blueprint code
	FUNC_BlueprintEvent		= 0x08000000,	// function can be overridden/implemented from a blueprint
	FUNC_BlueprintPure		= 0x10000000,	// function can be called from blueprint code, and is also pure (produces no side effects). If you set this, you should set FUNC_BlueprintCallable as well.
	// FUNC_				= 0x20000000,	// unused.
	FUNC_Const				= 0x40000000,	// function can be called from blueprint code, and only reads state (never writes state)
	FUNC_NetValidate		= 0x80000000,	// function must supply a _Validate implementation

	// Combinations of flags.
	FUNC_FuncInherit        = FUNC_Exec | FUNC_Event | FUNC_BlueprintCallable | FUNC_BlueprintEvent | FUNC_BlueprintAuthorityOnly | FUNC_BlueprintCosmetic,
	FUNC_FuncOverrideMatch	= FUNC_Exec | FUNC_Final | FUNC_Static | FUNC_Public | FUNC_Protected | FUNC_Private,
	FUNC_NetFuncFlags       = FUNC_Net | FUNC_NetReliable | FUNC_NetServer | FUNC_NetClient | FUNC_NetMulticast,
	FUNC_AccessSpecifiers	= FUNC_Public | FUNC_Private | FUNC_Protected,

	FUNC_AllFlags		= 0xFFFFFFFF,
};
ABlurCharacter *BlurCharacter = NewObject<ABlurCharacter>();
UClass *BlurCharacterClass = BlurCharacter->GetClass();
uint32 ClassFlags = BlurCharacterClass->ClassFlags;
GEngine->AddOnScreenDebugMessage(-1, 10.f ,FColor::Red, FString::FromInt(ClassFlags));

同理：这样就可以获取一些与类相关的信息

enum EClassFlags
{
	/** @name Base flags */
	//@{
	CLASS_None				  = 0x00000000,
	/** Class is abstract and can't be instantiated directly. */
	CLASS_Abstract            = 0x00000001,
	/** Save object configuration only to Default INIs, never to local INIs. Must be combined with CLASS_Config */
	CLASS_DefaultConfig		  = 0x00000002,
	/** Load object configuration at construction time. */
	CLASS_Config			  = 0x00000004,
	/** This object type can't be saved; null it out at save time. */
	CLASS_Transient			  = 0x00000008,
	/** Successfully parsed. */
	CLASS_Parsed              = 0x00000010,
	/** */
	//CLASS_                  = 0x00000020,
	/** All the properties on the class are shown in the advanced section (which is hidden by default) unless SimpleDisplay is specified on the property */
	CLASS_AdvancedDisplay	  = 0x00000040,
	/** Class is a native class - native interfaces will have CLASS_Native set, but not RF_MarkAsNative */
	CLASS_Native			  = 0x00000080,
	/** Don't export to C++ header. */
	CLASS_NoExport            = 0x00000100,
	/** Do not allow users to create in the editor. */
	CLASS_NotPlaceable        = 0x00000200,
	/** Handle object configuration on a per-object basis, rather than per-class. */
	CLASS_PerObjectConfig     = 0x00000400,
	
	/** pointers to this class default to weak. */
	CLASS_PointersDefaultToWeak = 0x00000800,
	
	/** Class can be constructed from editinline New button. */
	CLASS_EditInlineNew		  = 0x00001000,
	/** Display properties in the editor without using categories. */
	CLASS_CollapseCategories  = 0x00002000,
	/** Class is an interface **/
	CLASS_Interface           = 0x00004000,
	/**  Do not export a constructor for this class, assuming it is in the cpptext **/
	CLASS_CustomConstructor   = 0x00008000,
	/** all properties and functions in this class are const and should be exported as const */
	CLASS_Const			      = 0x00010000,

	/** pointers to this class default to weak. */
	CLASS_PointersDefaultToAutoWeak = 0x00020000,
	
	/** Indicates that the class was created from blueprint source material */
	CLASS_CompiledFromBlueprint  = 0x00040000,

	/** Indicates that only the bare minimum bits of this class should be DLL exported/imported */
	CLASS_MinimalAPI	      = 0x00080000,
	
	/** Indicates this class must be DLL exported/imported (along with all of it's members) */
	CLASS_RequiredAPI	      = 0x00100000,

	/** Indicates that references to this class default to instanced. Used to be subclasses of UComponent, but now can be any UObject */
	CLASS_DefaultToInstanced  = 0x00200000,

	/** Indicates that the parent token stream has been merged with ours. */
	CLASS_TokenStreamAssembled  = 0x00400000,
	/** Class has component properties. */
	CLASS_HasInstancedReference= 0x00800000,
	/** Don't show this class in the editor class browser or edit inline new menus. */
	CLASS_Hidden			  = 0x01000000,
	/** Don't save objects of this class when serializing */
	CLASS_Deprecated		  = 0x02000000,
	/** Class not shown in editor drop down for class selection */
	CLASS_HideDropDown		  = 0x04000000,
	/** Class settings are saved to <AppData>/..../Blah.ini (as opposed to CLASS_DefaultConfig) */
	CLASS_GlobalUserConfig	  = 0x08000000,
	/** Class was declared directly in C++ and has no boilerplate generated by UnrealHeaderTool */
	CLASS_Intrinsic			  = 0x10000000,
	/** Class has already been constructed (maybe in a previous DLL version before hot-reload). */
	CLASS_Constructed		  = 0x20000000,
	/** Indicates that object configuration will not check against ini base/defaults when serialized */
	CLASS_ConfigDoNotCheckDefaults = 0x40000000,
	/** Class has been consigned to oblivion as part of a blueprint recompile, and a newer version currently exists. */
	CLASS_NewerVersionExists  = 0x80000000,

	//@}


	/** @name Flags to inherit from base class */
	//@{
	CLASS_Inherit           = CLASS_Transient | CLASS_DefaultConfig | CLASS_Config | CLASS_PerObjectConfig | CLASS_ConfigDoNotCheckDefaults | CLASS_NotPlaceable
							| CLASS_PointersDefaultToAutoWeak | CLASS_PointersDefaultToWeak | CLASS_Const
							| CLASS_HasInstancedReference | CLASS_Deprecated | CLASS_DefaultToInstanced | CLASS_GlobalUserConfig,

	/** these flags will be cleared by the compiler when the class is parsed during script compilation */
	CLASS_RecompilerClear   = CLASS_Inherit | CLASS_Abstract | CLASS_NoExport | CLASS_Native | CLASS_Intrinsic | CLASS_TokenStreamAssembled,

	/** these flags will be cleared by the compiler when the class is parsed during script compilation */
	CLASS_ShouldNeverBeLoaded   = CLASS_Native | CLASS_Intrinsic | CLASS_TokenStreamAssembled,

	/** these flags will be inherited from the base class only for non-intrinsic classes */
	CLASS_ScriptInherit		= CLASS_Inherit | CLASS_EditInlineNew | CLASS_CollapseCategories,
	//@}

	/** This is used as a mask for the flags put into generated code for "compiled in" classes. */
	CLASS_SaveInCompiledInClasses = 
		CLASS_Abstract | 
		CLASS_DefaultConfig |
		CLASS_GlobalUserConfig |
		CLASS_Config |
		CLASS_Transient |
		CLASS_Native |
		CLASS_NotPlaceable |
		CLASS_PerObjectConfig |
		CLASS_ConfigDoNotCheckDefaults |
		CLASS_PointersDefaultToWeak |
		CLASS_EditInlineNew |
		CLASS_CollapseCategories |
		CLASS_Interface |
		CLASS_PointersDefaultToAutoWeak |
		CLASS_DefaultToInstanced |
		CLASS_HasInstancedReference |
		CLASS_Hidden |
		CLASS_Deprecated |
		CLASS_HideDropDown |
		CLASS_Intrinsic |
		CLASS_AdvancedDisplay |
		CLASS_Const |
		CLASS_MinimalAPI |
		CLASS_RequiredAPI,

	CLASS_AllFlags			= 0xFFFFFFFF,
};
ABlurCharacter *BlurCharacter = NewObject<ABlurCharacter>();
UClass *BlurCharacterClass = BlurCharacter->GetClass();
for(TObjectIterator<UClass> ClassIter; ClassIter; ++ClassIter)
{
	GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Yellow, ClassIter->GetName());
}

获取所有的类

ABlurCharacter *BlurCharacter = NewObject<ABlurCharacter>();
UClass *BlurCharacterClass = BlurCharacter->GetClass();
UFunction *PixelStr = BlurCharacterClass->FindFunctionByName("GetMousePixel");
GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Yellow, PixelStr->GetName());

通过方法名字查找到方法

ABlurCharacter *BlurCharacter = NewObject<ABlurCharacter>();
UClass *BlurCharacterClass = BlurCharacter->GetClass();
UFunction *PixelMethod = BlurCharacterClass->FindFunctionByName("GainMousePixel", EIncludeSuperFlag::ExcludeSuper);
if(PixelMethod->IsValidLowLevel())
{
	//分配空间并初始化为0
	uint8* LocSize = static_cast<uint8*>(FMemory_Alloca(PixelMethod->ParmsSize));//获取参数所占的空间大小来进行一个空间分配
	FMemory::Memzero(LocSize, PixelMethod->ParmsSize);
	//给方法内参数赋值
	for(TFieldIterator<UProperty> Pro(PixelMethod); Pro; ++Pro)
	{
		if(Pro->GetName() == FString("num"))
		{
			*Pro->ContainerPtrToValuePtr<FString>(LocSize) = "5";
		}
	}
    //使用ProcessEvent调用方法
	BlurCharacter->ProcessEvent(PixelMethod, LocSize);
}
void ABlurCharacter::GainMousePixel(FString num)
{
	GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Green, num);
}

使用ProcessEvent调用函数

AMyProjectPawn* MyProjectPawn = NewObject<AMyProjectPawn>();
UClass* BlurCharacterClass = MyProjectPawn->GetClass();
UFunction* PixelMethod = BlurCharacterClass->FindFunctionByName("GainMousePixel", EIncludeSuperFlag::ExcludeSuper);
if (PixelMethod->IsValidLowLevel()) {
	uint8* AllFuncParam = static_cast<uint8*>(FMemory_Alloca(PixelMethod->ParmsSize));
	FMemory::Memzero(AllFuncParam, PixelMethod->ParmsSize);
	FFrame Frame(nullptr, PixelMethod, &AllFuncParam);
	PixelMethod->Invoke(MyProjectPawn, Frame, &AllFuncParam + PixelMethod->ReturnValueOffset);
}
void AMyProjectPawn::GainMousePixel(FString num)
{
	GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Green, TEXT("VALUE = ") + num);
}

使用Invoke调用函数

反射数据的基类：

class COREUOBJECT_API UField : public UObject
{
	DECLARE_CASTED_CLASS_INTRINSIC(UField, UObject, CLASS_Abstract, TEXT("/Script/CoreUObject"), CASTCLASS_UField)
}

远离UE4
关注
UE4反射机制的通俗理解【CoreObject加载】
qq_40947718的博客
08-24 684
先大概看一下当运行项目时候的整个引擎启动流程。其中绿色的部分表示有涉及CoreUObject模块。 GuardedMain是真正的实现程序循环的地方。其中Engine开头的函数内部其实只是简单的转调一个全局的GEngineLoop的内部函数。 FEngineLoop GEngineLoop; int32 GuardedMain( const TCHAR* CmdLine, HINSTANCE hInInstance, HINSTANCE hPrevInstance, int32 nCmdShow
UE4 材质学习笔记12（水体反射和折射）
Mr_Dongzheng的博客
10-21 704
然后设置折射效果，当光从空气进入水中，由于空气和水的密度不同 光线会有一点弯曲，这就会导致水面下的东西看起来扭曲了，水的折射率是1.333，但是直接设置折射效果的话旋转视角会发现水会突然消失了。接下来我们要使用屏幕空间反射，在材质的细节面板，在“半透明”下 你可以看到有个属性是用于屏幕空间反射的，其作用是它会取用屏幕或者正在渲染的图像，而且如果一个像素需要反射，它会查看那个反射是否在屏幕上的任何其他像素上可用，但是屏幕空间反射的缺点是它们只能使用在屏幕上的数据.
UE4反射机制
wenshuifuping的专栏
12-24 181
实现机制？利用反射机制实现了什么供能
UE4 反射机制
qq_43021038的博客
05-29 1391
很多人问我虚幻与蓝图之间怎么进行通信，今天就跟大家说一下虚幻的反射机制。 第一 虚幻的构建系统的核心重点是UBT和UHT，UBT的作用是收集和构建编译环境，调用UHT生成代码，然后调用真正的编译器进行编译 - UHT的作用是翻译项目中所有C++的代码标记为真正的C++代码（如UCLASS/GENERATED_BODY等等），它属于UBT工作流程中的一环。 上面写的需要关注的有两点： 1. UEC++的代码必须通过UE自己的构建体系 2. UEC++的代码必须要通过UHT进行翻译成真正的C++代码 3. UE
UE4中的反射机制
wb175208的专栏
09-27 1752
在内容窗口右键鼠标弹出菜单选择【新建C++类】在弹出对话框中，勾选【显示所有类】选中Object,点击【下一步】输入一个名称和保存的位置，点击【创建类】在VS的项目中就多出两个文件MyObject.h和MyObject.cppMyObject.h中的代码。
UNREAL4 PROPERTY SYSTEM
weixin_33675507的博客
05-13 178
参见 https://www.unrealengine.com/blog/unreal-property-system-reflection ////////////////////////////////////////////////////////////////////////// // Base class for mobile units (soldiers) #includ...
UE4反射编程
weixin_44519692的博客
11-10 1254
B站学习的UE4反射编程的笔记
UE4 材质学习笔记10（程序化噪波/覆雪树干着色器/岩层着色器）
Mr_Dongzheng的博客
10-13 880
柏林噪波是一种能生成很好的随机图案的算法，它是一个无限的、不重复的图案，可以采用这种基础图案并以多种方式对其进行修改，将它缩放并进行多次组合，就可以创建一个分形图案。这些组合的缩放等级称为一个Octave这是产生柏林噪波基础图案的核心公式（优化版本）当这段代码被编译时，会产生下面的消耗，并且这只是核心图案，你通常把这个东西循环三到四次 甚至多达八次，所以你可以使用多达488个指令和64个纹理采样，所以这是非常耗能的。
UE4 材质学习笔记05（凹凸偏移和视差映射/纹理压缩设置）
Mr_Dongzheng的博客
10-08 1091
这需要一个高度图并且它的分辨率很低，只有256*256，事实上，如果高度图的分辨率比较低并且有点模糊，效果反而会更好然后将高度图输出到BumpOffset节点的height插槽中， 之后利用得到的UV进行贴图采样。现在移动摄像机的时候有一些视差移动，表面看起来不是平的，纹理坐标正在根据我的视角在移动。下面是分别使用两种方法效果的对比，后者看起来更有起伏感。
UE4 材质学习笔记01（什么是着色器/PBR基础）
Mr_Dongzheng的博客
10-03 1171
下面这个时材质的预览界面，右下角可以切换不同的形状，另外左上角还可以切换透视视图和正交视图然后左上角这个地方可以切换不同选项来查看模型，右面的显示可以隐藏或者显示网格，背景或者统计数据。PBR是基于物理的渲染，过去计算机图形只是试图模仿光线的外观，但是使用PBR是在模拟光线的实际行为。这样可以创建更逼真的图像。PBR有两个主要组成部分，光照属性和表面属性。光照属性主要由游戏引擎本身控制，表面属性则是由创建的着色器定义它们。
UE4反射机制学习
Haipai1998的博客
06-22 681
UE4中反射用于什么情况？ #define UPROPERTY(...) #define UFUNCTION(...) #define USTRUCT(...) #define UMETA(...) #define UPARAM(...) #define UENUM(...) #define UDELEGATE(...) // This pair of macros is used to help implement GENERATED_BODY() and GENERATED_USTRUCT_BOD
UE4 C++ 反射机制详解
最新发布
小宝哥Code的专栏
03-18 830
C++ 类可以暴露给蓝图，允许在蓝图中使用 C++ 逻辑。Unreal Engine 4（UE4）的。，允许开发者动态访问类、函数、属性。进行垃圾回收，避免内存泄漏。：自动管理属性的保存、加载。：支持多人游戏中的数据同步。，适用于存储数据（如。
UE4反射原理（转）
weixin_42111061的博客
09-20 1216
转自： https://blog.csdn.net/mohuak/article/details/81913532 https://blog.csdn.net/u012999985/article/details/52902065 1. UE4反射系统 什么是反射系统 在UE4里面，你无时无刻都会看到类似UFUNCTION（）这样的宏。官方文档告诉你，只要在一个函数的前面加上这个宏，然后在括号里面加上BlueprintCallable就可以在编辑器里面调用了。按照他的指示，我们就能让我们的函数实现各种各样特
UE4——反射原理（一）
weixin_43945471的博客
12-28 1705
UE4——反射原理（一） 上一篇文章 由于最上面的类图尺寸过大，上传后的图片并不是特别清晰，高清原图可以在这里下载。 从上面可以看出UObject是整个反射系统核心，UE4中支持反射的类型在上一篇文章中已经说过，包括 C++类、结构体、函数 、成员变量以及枚举，也支持TArray（只支持一些如TArray和TSubclassOf的模板类型，并且它们的模板类型不能是嵌套的类型），但是TMap不支持。而这些东西的支持与上面的类是分不开的，比如UClass、UBlueprintGeneratedClass、UF
UE4反射机制的通俗理解【代码生成】
qq_40947718的博客
09-19 3419
UE4反射机制主要分为以下几个阶段 生成阶段：借助UHT生成对应包含了反射声明的反射代码 收集阶段：借助static自动注册方式，在模块加载的时候，把UCLASS注册，放在array中管理 注册阶段：在模块初始化的时候，将Array中的所有UClass相关的Function和Property注册； 链接阶段：就是反射功能。 第一阶段 在介绍第一阶段前，先介绍两个工具，ubt和uht。UBT是UE4自带的C++工具，用来处理文件依赖，包含。（待理解） UHT则是UE4自带的C++解...
UE4 C++反射从入门到原理剖解(UE4 4.26)
qq_29523119的博客
08-05 6510
UE4 C++反射具体应用案例 测试反射类ATestActor // Fill out your copyright notice in the Description page of Project Settings. #pragma once #include "CoreMinimal.h" #include "GameFramework/Actor.h" #include "TestActor.generated.h" UCLASS(Blueprintable, meta = (Dis..
UE4反射机制的通俗理解【信息收集】
qq_40947718的博客
08-21 570
上一篇文章讲了代码上添加宏之后，会展开成各种变量定义和函数定义。其中最主要的就是两个static变量，static变量会在Main函数执行前自动初始化，我们可以在他的构造函数中写上我们想要执行的代码逻辑，这样就可以在程序启动时自动执行。 上篇中写到的生成了那么多的类的信息，分散在各个类的.h 和 .cpp文件中，那么怎么把这些信息统一的记录下来呢，就依赖于static变量的信息收集。我们一个一个看，先是class~ static TClassCompiledInDefer<UMyClass&gt
Java反射如何获取jar包下的某个类的所有子类？
强哥叨逼叨
10-28 2892
首本来觉得实现这个功能应该挺简单的，而且市面上也已经有了开源的工具比如：Reflections，简单的两句代码就能实现这个功能： Reflections reflections = new Reflections("my.project"); Set<Class<? extends SomeType>> subTypes = reflections.getSubTypesOf(SomeType.class); 这个在本地Idea调试时确实也都比较好用。不过，当遇到需要加载依
UE里的反射(Reflections)机制
alexhu2010q的博客
01-31 2522
由于C++语言是不支持反射的，像UE这种引擎为了支持反射，就只能自己设计一套系统了，UE里这套系统叫做Unreal Header Tool (UHT)，实现反射的核心思路也比较清晰明了，就是让用户在需要支持反射的类代码里加对应的宏，然后UHT在编译的时候会为其生成相关代码，比如要给一个变量加到反射系统里，就在它前面给它加一个UPROPERTY的宏(有点类似于C#里的给Property加Attribute)。
ue4学习笔记 rapdo
07-25
抱歉，我无法回答你的问题。 #### 引用[.reference_title] - *1* *2* *3* [UE4学习笔记--EQS系统](https://blog.csdn.net/gzy252050968/article/details/104905275)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值