I’ve always wanted to try using an engine, and I feel like this is an opportunity to finally understand the internal workings of an engine that I had been ignoring for so long. I remember reading a book called 'Making a □□□ Game with C' in the past, and I recall it used the sleep() function for fixed frames. That's why the technique of specifying frames at the beginning was so fascinating to me.🤔 I used to always be interested but would end up turning away from game development after hitting the wall of the engine (its various features and interface...). However, thanks to your excellent explanations, my fear of engines seems to have faded a bit. Since you explain the lifecycle and operational processes, I think those who are intimidated by the vastness of an engine can get one step closer to game systems by building a lightweight engine themselves. Since the course takes place entirely within Visual Studio, I can pause the video, follow along with the coding, and learn while listening to the explanations. The lecture duration is a bit long, but personally, I found it great because I feel that typing along is more effective for learning. The lecture notes summarize what was covered and why, so I even used Gemini to create quizzes for review. Although you follow along while looking at the code, I think the learning effect will be better if you are somewhat familiar with C++ to keep up with the lecture pace. C++ is difficult for me, so my progress is a bit slow, but I am still very satisfied with the course. I will continue to study hard!! 🥰

Through this course, I was able to understand the basic overview of a game engine by building one myself, which allowed me to infer that commercial engines likely operate in a similar manner internally. In particular, while looking at the engine and renderer code structured using the Singleton pattern, I was once again able to feel how excellent code can be when a program is built through proper design. By changing project settings in Visual Studio, I learned practical knowledge not typically covered in school classes—such as managing project folders and building engine code as a separate DLL to link it rather than just running a simple executable. This made me feel like I’ve taken another step closer to becoming a professional developer. I believe this will be a great help to those who want to understand game engines.

I highly recommend this course to those who want to go beyond simply using the features provided by commercial engines and instead wish to directly design and understand the fundamental internal structure of a game engine. Through this lecture, I was able to gain deep insights into the operating principles of core functions, such as the actor lifecycle and tick management. In particular, learning how to control memory directly with C++ to prevent resource leaks and implementing custom RTTI to handle object inheritance and safe downcasting were invaluable experiences that cannot be gained through superficial study. Furthermore, the process of building the engine as a DLL to separate and link it provided practical CS knowledge that is difficult to encounter in standard university major courses or general tutorials. If you are a developer who wants to know the real reasons behind how engines like Unreal or Unity work internally, I strongly urge you to take this course.

Through Instructor RonnieJ’s ‘Game Engine Framework with C++’ course, I was able to build a very solid foundation in game engine development. While studying development, I had encountered various concepts related to game engines and CS, but I found it difficult to explain them accurately or organize them systematically. Through this class, I was able to clearly understand concepts that were previously confusing and organize them to the point where I can explain them myself. Beyond just understanding the overall flow of how an engine is structured and operates, I was able to learn the actual operating principles by directly implementing core concepts such as the game loop, actor and level-based world management, fixed-frame update structures, input processing systems, double-buffered rendering, and AABB collision detection. Designing the engine/content structure through DLL separation and implementing a custom type system (RTTI) was also very helpful. After completing this course, I am now learning Unreal Engine, and I naturally understood things like the DLL keywords and casting used in Unreal headers. Additionally, in an era overflowing with flashy graphics, I was satisfied to be able to create my own unique game by implementing a console-based game. The course structure was also very helpful for learning. By following the class materials provided for each lecture, the summaries at the bottom of the videos, and the checkpoints, I was able to review efficiently without missing important concepts. I believe this is not just a class where you simply make a game, but a lecture that allows you to understand the core structure of a game engine and elevate your mindset as a developer to the next level. For those who want to start game engine development or those studying development, this is a truly precious, unicorn-like lecture!!! I strongly recommend it to those who want to properly understand game engines and to developers who want to grow one step further!!

Everyone knows that understanding an engine is necessary for employment, but I think what that "understanding" actually means is quite abstract. This lecture explains the principles of how commercial game engines operate. It creates a game loop using concepts used in Unreal Engine (Actor, Level) and provides detailed explanations of RTTI concepts, which allow for a custom approach to downcasting. Additionally, when looking at Unreal Engine code, I didn't really know what the `ProjectName_API` prefix before class names was for, but after taking this lecture, I learned it is for using DLLs. I also gained a detailed understanding of the concept of separating engine code from content code.