Welcome back to our game engine series, where we dive into the world of game development. In our previous video, we explored precompiled headers, so make sure to check it out if you haven’t already. Today, we are finally going to create a window that will serve as our canvas to render amazing stuff.
Creating a window is a crucial step in any game engine. However, it’s important to consider when to introduce it in the development process. Typically, beginners tend to start with creating a window as it allows them to visualize the progress and see the game come to life. But as you learn more about game engine architecture, you realize that there are many other components to consider, such as the event system, application system, layer stack system, and more.
In this game engine series, we want to strike a balance between entertainment, education, and software engineering. Therefore, we have decided to create a window now to maintain interest and engagement. However, we want to emphasize that there is much more to a game engine than just a window. So stay tuned as we explore other components in future episodes.
To create our window, we will be using an amazing library called GLFW. GLFW is a simple cross-platform library that allows us to create windows and handle events. It supports multiple platforms like Windows, Mac, and Linux, making it a versatile choice for our game engine. We have forked the GLFW repository and added it to our project as a submodule, making it easy to integrate with our code.
Within our project, we have introduced a Window class, which serves as an abstract representation of a window. The Window class encapsulates platform-specific code and provides a uniform interface for interacting with the window across different platforms. This abstraction allows us to support multiple platforms seamlessly.
The Window class has various properties and functions, including event callbacks, initialization, shutdown, and more. We have implemented a create function that returns a platform-specific window class based on the platform we are compiling for. In our case, we have implemented the create function specifically for Windows, but we could extend it to support other platforms like Mac and Linux in the future.
To test our window creation, we have integrated OpenGL into our code. In our application class, we create a unique pointer to the Window class and initialize it within the constructor. We set up a loop that continuously updates the window by calling the on update function. Within the on update function, we have added some OpenGL code to clear the color buffer and set the window to a beautiful pink color.
With this setup, we have successfully created a window with an OpenGL context. However, we still need to handle events such as key presses, mouse interactions, and window resizing. In our next episode, we will explore event handling and connect it to our application class, allowing us to respond to user input and create interactive experiences.
Stay tuned for more exciting updates in our game engine series. Remember, building a game engine is a fascinating journey that requires dedication, creativity, and a thirst for knowledge. So keep exploring, keep experimenting, and let your imagination run wild. Happy coding!
Techal is your ultimate source for all things technology, helping you stay informed, inspired, and empowered. Join our community today and revolutionize your game engine development journey!
