unreal | Reinforcement learning with unsupervised auxiliary tasks | Machine Learning library

Have you tried installing C++ editor? as example, you can install visual studio.To add C++ tools to your VS installation, make sure you select Game development with C++ under Workloads. that worked for me

Add takes in an FDelegate.

AddUObject is syntactic sugar for creating a templated delegate and binding it to the provided UObject, then calling Add with the created delegate.

It is just this:

Dug a little bit deeper, so I'll try to answer this myself. I believe that for a normal C++ class it would be undefined behaviour as I cannot find any info suggesting otherwise for bit-fields specifically.

For the UE4 example, most objects in the engine including the cited UPrimitiveComponent example are derived from UObject, and I did find deep in the documentation that these are automatically zero initialized:

Automatic Property Initialization UObjects are automatically zeroed on initialization, before the constructor is called. This happens for the whole class, UProperties and native members alike. Members can subsequently be initialized with custom values in the class constructor.

https://docs.unrealengine.com/4.27/en-US/ProgrammingAndScripting/ProgrammingWithCPP/UnrealArchitecture/Objects/Optimizations/

In the code this will happen in StaticAllocateObject in UObjectGlobals.cpp, the memory is earlier malloc'd and then FMemory::Memzero is called which ultimately uses memset to zero the memory

Look for documentation of FVector. Search "operators". Look for |. Find:

The relevant section of compiled code for option-1 looks like

There are two separate questions here: what does this code do, and does it work?

One common way that vtables are implemented is by storing a pointer to the vtable at the base of the object. So, for example, on a 32-bit machine, the first four bytes of the object would be a pointer to the vtable, and on a 64-bit machine the first eight bytes of the object would be a pointer to the vtable.

With that in mind, let’s think about what *(void**)this does. The this pointer points to the base of the object. We want to interpret the beginning of that object as a pointer to a vtable, so we want to get the value of the pointer at the base of the object. However, we don’t have a name for that pointer, so we can’t look it up by name, and because the vtable is set up by the compiler there is no C++ type that corresponds to “a vtable.” So instead, we’ll do the following. We’ll envision the pointer we want to read as being a void* (a pointer to “something whose type we don’t know.”) The this pointer is pointing right at that void*, so we’ll introduce a cast of (void**)this to say “pretend that this points at a void*.” We then dereference that pointer to read the void* that’s stored there, which is our vtable pointer. Collectively, that gives us *(void**)this.

The next question is why the null-check works. In a general, this safety check won’t work. It presumes that when space for an object is allocated, the memory is set to all 0s before the object is constructed. Assuming that’s the case, if the vtable pointer hasn’t been set up, then the bytes allocated to it would be 0s, which on some C++ implementations is treated as a null pointer. So the check you’ve listed here would then read the vtable pointer, see if it’s null, and then report an error if it is.

However, there’s a lot of assumptions there - that the memory is nulled out before the object is constructed, that the vtable is at the exact base of the object, etc. I’m not familiar with the specifics of the Unreal engine, but I assume it probably is set up to ensure these requirements are met.

Regardless of the crashing issue, you will likely have to limit yourself to one screenshot per frame anyway, since you will want to give the renderer time to update with the new camera angle before taking the screenshot.

So I would recommend having an Index variable on your blueprint, and every frame you:

1. Take a screenshot
2. ++Index
3. If Index >= CameraTransforms.Count, exit
4. Else, set the camera to CameraTransforms[Index]

Then wait till next frame. The reason I recommend taking a screenshot first is so that you've given the game/render threads time to update the last camera transform you set at the end of the last frame.

Hope that helps! P.s. You may want to look into Sequencer, and specifically rendering out videos from it. The workflow would be roughly the same as what I outlined above, but you could skip the screenshot step and render out an image sequence instead. I don't have a full end-to-end solution for you there, just planting an idea for you to look into if you want.

So I write a script to fix this.