Let’s say you’ve created your own USTRUCT in C++ and now you want to serialize it.
Usually, it’s enough to simply mark the desired fields with SaveGame. But here’s the problem — in order for this to work, the fields themselves must support serialization.
Unfortunately, one of our variables doesn’t.
In my case, it’s a struct called FNonSerializableStruct. Because of that, only the second struct gets serialized, even though we marked both with SaveGame.
If you’ve been working with Unreal Engine for a while, you’ve probably come across nodes that let you call a function now and get the result later — while also continuing execution once the function completes.
I needed to create a category panel for placeable items in the UI — like the ones you see in city-building games. As a legacy, I inherited a ready-made UENUM, which may be modified in the future.
Naturally, I didn’t want to manually create and tweak every single widget — especially knowing that the list of categories might change later. I wanted something simple and reusable: just run a For each loop, generate everything on the fly, and ideally make it work for any enum, not just this one.
And there was a way! When you define a UENUM, Unreal automatically generates all the metadata and creates a corresponding UEnum object, which is a UObject. All you have to do is use that data properly.
Gen Z – a generation of young people born between the last few years of the 20th century and the first ten years of the 21st, are the primary users of a modern-day Internet. They started using technology since their early childhood, being almost constantly glued to their smartphones and tablets, which led to them being very demanding users that have their own requirements in UX. At the same time, they are known for their sense of humor and straightforwardness – which means they love using products that are both easy to navigate but full of interactive elements. Below we’ve collected a few things you should consider when creating a UX design aimed at a young audience.
I always pay attention to assessing the complexity of programming in a particular language. Programming is indeed not an easy task and this is perceived as a fact and usually does not require any confirmation.
But the concept of “complexity” is akin to the term “heap”. For some, five coconuts is not so much, but for someone who ate one and “didn’t want any more,” this means that even one coconut will be too much for him.
The same goes for the complexity of programs. It seems that the constant increase in the complexity of programs is obvious to everyone and is observed in all areas of application of IT technologies, and programming languages themselves become more and more complex as they develop, but assessing “complexity” using numerical metrics is a problem. obviously a thankless task, but also “You can’t manage what you can’t measure...”
Typically, talk of “complexity” only implies value judgments without any numerical evaluation. And since I am personally interested in the issue of the complexity of programming languages, I decided to calculate the complexity of implementing the gcc compiler on some conditional “parrots”. What if we could see some patterns of difficulty changing over time?
One of the common tasks that both beginners and experienced game designers face is describing a large amount of content to pass its parameters to the engine. This is not an easy task, given that it is very difficult to find materials on the technical aspects of game design. Well, let’s figure out how to transfer data to the engine.
So you want to learn more about game engines and write one yourself? That's awesome! To help you on your journey, here are some recommendations of C++ libraries and dependencies that will help you hit the ground running.
One of the mechanisms of static analysis is method annotations of popular libraries. Annotations provide more information about functions during errors detecting. CARLA is an impressive open-source project in C++ that helped us implement this mechanism to our analyzer. Subsequently, the simulator became a test-target for the improved PVS-Studio static analyzer.
"How much longer are you going to build it?" - a phrase that every developer has uttered at least once in the middle of the night. Yes, a build can be long and there is no escaping it. One does not simply redistribute the whole thing among 100+ cores, instead of some pathetic 8-12 ones. Or is it possible?
