编程

Virtualbox memo

by 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

hgcmThread, hgcmServiceThread
	HGCM_MSG_CONNECT
	HGCM_MSG_REGEXT
	SVC_MSG_HOSTCALL // when drag and drop occurs
src/VBox/HostServices/DragAndDrop/VBoxDragAndDropSvc.cpp:1071
	DragAndDropService::hostCall
src/VBox/Frontends/VirtualBox/src/main.cpp:939
src/VBox/Main/src-client/ConsoleImpl.cpp
	VMR3Create
src/VBox/HostServices/GuestProperties/VBoxGuestPropSvc.cpp
	Service::call
		GUEST_PROP_FN_GET_PROP
		GUEST_PROP_FN_SET_PROP
		GUEST_PROP_FN_SET_PROP_VALUE
		GUEST_PROP_FN_DEL_PROP
		GUEST_PROP_FN_ENUM_PROPS
		GUEST_PROP_FN_GET_NOTIFICATION

ue4 memo

by

Terms,

1
2
3
4
5
6
7
8
9
10
11
12

XGE
RHI: Render Hardware Interface
IncrediBuild
fastbuild
反射系统
蓝图系统
UBT: Unreal Build Tool
UHT: Unreal Heading Tool
CDO: Class Default Object
NM: Net Mode
LLM: Low Level Mem
GEngineIni: ThirdPerson01/Saved/Config/Windows/Engine.ini

Apis

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Yellow, FString::Printf(TEXT("Hello, %s."), TEXT("Euhat")));
 
TRACE_OBJECT_EVEN
UE_TRACE_CHANNELEXPR_IS_ENABLED(ObjectChannel)
 
FD3D11DynamicRHI::RHIBeginFrame
 
UWorld
	PlayerControllerList
		PlayerController_0
			AGameplayDebuggerCategoryReplicator
	for (ULevel* Level : InWorld->GetLevels())
		Level->Actors
			WorldInfo_0			{AWorldSettings}
			Brush_0				{ABrush}
			LightmassImportanceVolume_0	{ALightmassImportanceVolume}
			AtmosphericFog_1		{AAtmosphericFog}
			SkySphereBlueprint		AActor *
			SphereReflectionCapture		{ASphereReflectionCapture}
			NetworkPlayerStart		{APlayerStart}
			DocumentationActor1		{ADocumentationActor}
			Linear_Stair_StaticMesh		{AStaticMeshActor}
			Bump_StaticMesh			{AStaticMeshActor}
			LeftArm_StaticMesh		{AStaticMeshActor}
			RightArm_StaticMesh		{AStaticMeshActor}
			Ramp_StaticMesh			{AStaticMeshActor}
			CubeMesh_5			{AStaticMeshActor}
			LightSource_0			{ADirectionalLight}
			PostProcessVolume_0		{APostProcessVolume}
			SkyLight_0			{ASkyLight}
			Floor_1				{AStaticMeshActor}
			Wall7_4				{AStaticMeshActor}
			Wall9				{AStaticMeshActor}
			Wall10				{AStaticMeshActor}
			Wall11				{AStaticMeshActor}
			TextRenderActor_1		{ATextRenderActor}
			AMyActor_9			{UE4Editor-ThirdPerson01-0013-Win64-Debug.dll!AAMyActor}
			DefaultPhysicsVolume_0		{ADefaultPhysicsVolume}
			GameplayDebuggerPlayerManager_0	{UE4Editor-GameplayDebugger-Win64-Debug.dll!AGameplayDebuggerPlayerManager}
			ThirdPersonGameMode_C_0		{AGameModeBase}
			GameSession_0			{AGameSession}
			ParticleEventManager_0		{AParticleEventManager}
			GameNetworkManager_0		{AGameNetworkManager}
			ThirdPersonCharacter_167	{ACharacter}
			ThirdPersonExampleMap_C_0	{ALevelScriptActor}
			GameStateBase_0			{AGameStateBase}
			AbstractNavData-Default		{UE4Editor-NavigationSystem-Win64-Debug.dll!AAbstractNavData}
			PlayerController_0		{APlayerController}
			PlayerState_0			{APlayerState}
			PlayerCameraManager_0		{APlayerCameraManager}
			CameraActor_0			{ACameraActor}
			HUD_0				{AHUD}
 
AActor
	RootComponent
	OwnedComponents : TSet<UActorComponent*>
	InstanceComponents 
	Children
 
UActorComponent
	OnRegister
	CreateRenderState
	OnCreatePhysicsState
	OnUnregister
	DestroyRenderState
	OnDestroyPhysicsState
	TickComponent
	PrimaryComponentTick.bCanEverTick
	PrimaryComponentTick.SetTickFunctionEnable(true)
	MarkRenderStateDirty
 
USceneComponent : UActorComponent
	SetupAttachment
	AttachToComponent
 
	FTransform
 
UPrimitiveComponent : USceneComponent
	ShouldCreatePhysicsState
 
	Box Component
	Capsule Component
	Mesh Component
	Skeletal Mesh Component
 
UDrawFrustumComponent : UPrimitiveComponent

stat

1
2
3

stat unit
stat SceneRendering
stat gpu

LineTraceSingle

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

void AMyCharacter::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);
 
	const float TRACE_LINE_LENGTH = 1000.0f;
	FRotator actorRotator = GetActorRotation();
	const FRotator YawRotation(0, actorRotator.Yaw, 0);
	const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
	FVector lineStartPos = GetActorLocation();
	FVector lineEndPos = lineStartPos + TRACE_LINE_LENGTH * Direction;
	TArray<AActor*> arrayIgnoreActor;
	FHitResult outResult;
	if (UKismetSystemLibrary::LineTraceSingle(GetWorld(), lineStartPos, lineEndPos, 
			ETraceTypeQuery::TraceTypeQuery1, true, arrayIgnoreActor, 
			EDrawDebugTrace::ForDuration, outResult, true, 
			FLinearColor::Red, FLinearColor::Green, 0.1f))
	{
		FString locationString = outResult.Location.ToString();
		UE_LOG111(LogTemp, Error, TEXT("location = %s"), *locationString);
	}
}

refer to:
https://www.cnblogs.com/fjz13/p/5956393.html
https://blog.csdn.net/qq_29523119/article/details/85957072

debug ue4 completely

by

The default "Debug Editor" mode will produce a beast of UE4Editor that we can't debug it thoroughly, for vs2022 needs over 10G memory to load relative pdbs and retrieve debug information, eventually our computer is over burden, and vs2022 corrupts, so we never so much as trigger a debug point.

After several mends, vs2022 IDE still corrupts at beginning of debugging, so we have to seek help from WinDbg or QtCreator.

There are two main causes why UE4Editor is so big:

  • The original build tool action is 'Modular' which generates many dlls and every dll contains a portion of the same low level library code. So we change the action to 'Monolithic':

    ue\Engine\Source\Programs\UnrealBuildTool\Configuration\TargetRules.cs

    ...
		public TargetLinkType LinkType
		{
			get
			{
//				return (LinkTypePrivate != TargetLinkType.Default) ? LinkTypePrivate : ((Type == global::UnrealBuildTool.TargetType.Editor) ? TargetLinkType.Modular : TargetLinkType.Monolithic);
				return (LinkTypePrivate != TargetLinkType.Default) ? LinkTypePrivate : ((Type == global::UnrealBuildTool.TargetType.Editor) ? TargetLinkType.Monolithic : TargetLinkType.Monolithic);
			}
			set
			{
				LinkTypePrivate = value;
			}
		}
...

    But I have tried building in monolithic mode, it's a suicide, literately, there are many duplicated symbols generated which fail the building. We have to return to modular mode.

  • Every call on logging macro carves '__FILE__' or '__FUNCTION__' in the binary which will also inflate the executable. So we change these macros to nonsense:

    ue\Engine\Source\Runtime\Core\Public\Misc\Build.h

    ...
#define EUHAT_MINIMIZE 1

#if UE_BUILD_DEBUG
#if EUHAT_MINIMIZE
	#ifndef DO_GUARD_SLOW
		#define DO_GUARD_SLOW			0
	#endif
	#ifndef DO_CHECK
		#define DO_CHECK			0
	#endif
	#ifndef DO_ENSURE
		#define DO_ENSURE			0
	#endif
	#ifndef STATS
		#define STATS				((WITH_UNREAL_DEVELOPER_TOOLS || !WITH_EDITORONLY_DATA || USE_STATS_WITHOUT_ENGINE || USE_MALLOC_PROFILER || FORCE_USE_STATS) && !ENABLE_STATNAMEDEVENTS)
	#endif
	#ifndef ALLOW_DEBUG_FILES
		#define ALLOW_DEBUG_FILES		1
	#endif
	#ifndef ALLOW_CONSOLE
		#define ALLOW_CONSOLE			0
	#endif
	#ifndef NO_LOGGING
		#define NO_LOGGING			0
	#endif
#else
	#ifndef DO_GUARD_SLOW
...

    We should notice NO_LOGGING is false, I attempted to set it true, but a lot of errors occured.

    At the end of ueDbg\Engine\Source\Runtime\Core\Public\Logging\LogMacros.h

    ...
#if EUHAT_MINIMIZE
	#undef UE_LOG
	#undef UE_LOG_CLINKAGE
	#undef UE_CLOG
	#undef UE_SUPPRESS
	#undef UE_SECURITY_LOG

	#define UE_LOG(CategoryName, Verbosity, Format, ...) 
	#define UE_LOG_CLINKAGE(CategoryName, Verbosity, Format, ...) 
	#define UE_CLOG(Condition, CategoryName, Verbosity, Format, ...) 
	#define UE_SUPPRESS(...) {}
	#define UE_SECURITY_LOG(...)
#endif

And if we wanna debug inline functions, modify this place:

ue\Engine\Saved\UnrealBuildTool\BuildConfiguration.xml

<?xml version="1.0" encoding="utf-8" ?>
<Configuration xmlns="https://www.unrealengine.com/BuildConfiguration">
	<BuildConfiguration>
		<bAllowXGE>true</bAllowXGE>
		<bUseInlining>0</bUseInlining>
	</BuildConfiguration>
</Configuration>

'bAllowXGE' means to turn on IncreBuild, while the prerequisite is we have very big memory.

There are still some nasty things to do:

  1. Invoking empty macro is considered as a warning 4390, existing unused variables is considered as warning 4101, they will cease ue4 compilation.

    ue\Engine\Source\Runtime\Core\Public\Windows\WindowsPlatformCompilerSetup.h

    #pragma warning (error: 4100      4102 4103                          4109           4112 4113 4114 4115 4116 4117      4119 4120 4121 4122 4123 4124 4125      4127      4129 4130 4131 4132 4133                4137 4138           4141 4142 4143 4144 4145 4146                4150      4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164      4166 4167 4168                4172      4174 4175 4176 4177 4178 4179 4180 4181 4182 4183      4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197      4199)

#pragma warning (error:      4301 4302 4303           4306      4308 4309 4310           4313 4314 4315 4316      4318 4319      4321 4322 4323 4324 4325 4326 4327 4328 4329 4330           4333 4334 4335 4336 4337 4338      4340           4343 4344      4346      4348                4352 4353      4355 4356 4357 4358 4359           4362      4364      4366 4367 4368 4369                     4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384           4387      4389      4391 4392 4393 4394 4395 4396 4397 4398 4399)

    ue\Engine\Source\Programs\UnrealBuildTool\Platform\Windows\VCToolChain.cs

    ...
			// Set warning level.
			if (Target.WindowsPlatform.Compiler != WindowsCompiler.Intel)
			{
				// Restrictive during regular compilation.
				// Euhat Modified
				//Arguments.Add("/W4");
				Arguments.Add("/wd4101");
				Arguments.Add("/W0");
			}
...
			// Prevents the linker from displaying its logo for each invocation.
			Arguments.Add("/NOLOGO");
			// Euhat modified
			Arguments.Add("/FORCE:MULTIPLE");
...

    'FORCE:MULTIPLE' means just to pick the first one of the same name symbols instead of complaining as a link error.

  2. ue\Engine\Plugins\Slate\SlateInsights\Source\SlateInsights\Private\SlateInsightsModule.cpp

    //IMPLEMENT_MODULE((UE::SlateInsights::FSlateInsightsModule), SlateInsights);
  3. ue\Engine\Source\Runtime\AudioMixer\Public\AudioMixerDevice.h

    		// make it public
		FAudioPlatformDeviceInfo PlatformInfo;

    ue\Engine\Plugins\Media\BinkMedia\Source\BinkMediaPlayer\Private\BinkMediaPlayerPCH.h

    ...
			//return mix->GetNumDeviceChannels();
			return mix->PlatformInfo.NumChannels;
...
//DECLARE_LOG_CATEGORY_EXTERN(LogBink, Log, All);
...

    ue\Engine\Plugins\Media\BinkMedia\Source\BinkMediaPlayer\Private\BinkMediaPlayerModule.cpp

    //DEFINE_LOG_CATEGORY(LogBink);
  4. ue\Engine\Plugins\Runtime\AR\Microsoft\HoloLensAR\Source\HoloLensTargetPlatform\HoloLensTargetPlatform.Build.cs

    bEnableUndefinedIdentifierWarnings = false;

The last thing kept in mind is don't build the whole resolution, for simultaneous compilations of projects can easily run out of memory. Just right click Engine/EU4 and build UE4Editor only.

ps: We use UnrealEngine-4.27.2-release.zip in this article.

custom widget in qt

by

TstUsrCtrl.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#pragma once
 
#include <qwidget>
 
class TstUsrCtrl : public QWidget
{
	Q_OBJECT
 
	QPoint oldPos_;
	QPoint curPos_;
 
public:
	explicit TstUsrCtrl(QWidget *parent = nullptr);
	~TstUsrCtrl();
 
	void paintEvent(QPaintEvent* event);
	void mousePressEvent(QMouseEvent* event);
	void mouseMoveEvent(QMouseEvent* event);
	void mouseReleaseEvent(QMouseEvent* event);
	void mouseToPosition(QMouseEvent* event);
};
</qwidget>

Read more

weird wildcards in format string argument of printf

by

to output in decimal notation of a char variable, we write like this

1
2

char a1 = 'a';
printf("a1 is [%d].\n", a1);

in the way we output an int variable.

but when we output a long variable, we must write like below reluctantly

1
2
3

#need to test in gcc.
long l1 = 123456789;
printf("l1 is [%ld].\n", l1);

don't say byte alignment.

can't trace heap memory while debug with exe dump

by

many projects using MiniDumpWriteDump generate executable dump file while exe is corrupted.

but usually they couldn't analysis the malloc-ed or new-ed variables with the dump file.

using MiniDumpWithFullMemory argument instead of MiniDumpNormal to call MiniDumpWriteDump will complement us.

references to including header

by 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#include <memory>
unique_ptr
shared_ptr
enable_shared_from_this
 
#include <algorithm>
remove
find
remove_if
find_if
 
#include <sstream>
istringstream
ostringstream
stringstream
 
#include <stdint.h>
int64_t
 
#include <unistd.h>
sleep

c++ move forward

by

lvalue: loactor value
rvalue: read value

here is an example of class definition with only one constructor using template and 'forward' technique to tackle varying parameter:

rvalue.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

#include <iostream>
#include <functional>
 
using namespace std;
 
template <typename T>
constexpr bool is_lvalue(T&) {
	return true;
}
 
template <typename T>
constexpr bool is_lvalue(T&&) {
	return false;
}
 
class MyStr
{
public:
	template<class T>
	MyStr(T&& t)
	{
		set(forward<T>(t));
	}
	template<class T>
	void set(T&& t)
	{
		if constexpr (conjunction_v<is_convertible<T&, MyStr&>>)
		{
			if (!is_lvalue(forward<T>(t)))
			{
				str_ = forward<string>(t.str_);
				cout << "is rvalue, type MyStr." << endl;
			}
			else
			{
				str_ = t.str_;
				cout << "is lvalue, type MyStr." << endl;
			}
		}
		else
		{
			str_ = forward<T>(t);
			cout << "is string." << endl;
		}
	}
	template<class T=char>
	void test()
	{
		cout << "test T size is " << sizeof(T) << endl;
	}
	string str_;
};
 
int main()
{
	cout << "call constructor:" << endl;
 
	MyStr str1("str1");
	MyStr str2(str1);
	MyStr str3(move(str1));
 
	cout << "call member function:" << endl;
 
	str1.set("set1");
	str2.set(str1);
	str3.set(move(str1));
 
	str3.test();
 
	return 1;
}

make

1

g++ -o rvalue -g -O0 -std=c++17 rvalue.cpp

output

1
2
3
4
5
6
7
8

call constructor:
is string.
is lvalue, type MyStr.
call member function:
is string.
is lvalue, type MyStr.
is rvalue, type MyStr.
test T size is 1

refer to:
http://www.javashuo.com/article/p-olwxiggw-q.html
http://c.biancheng.net/view/7829.html
https://zhuanlan.zhihu.com/p/99524127