Abstract:

This video introduces a software architecture pattern for real-time applications and games, emphasizing simplicity and separation of concerns. The core concept is to divide the project into two main parts: a reusable "Core" library and the application-specific "App" executable.

The Core library encapsulates foundational systems like the main application loop, window management (using GLFW and OpenGL), timing, and a layer-based system for injecting custom behavior. The App module contains the unique logic for a specific program, implemented as one or more "Layers." A Layer is a class with overrideable functions like onUpdate, onRender, and onEvent, providing a clean, sandboxed environment for developers. The video demonstrates how a minimal main() function can initialize the application using a configuration struct, push a custom layer, and start the main loop, which is managed entirely by the Core library. This approach results in a clean, scalable, and organized codebase where application logic is neatly decoupled from engine boilerplate.

Building a Clean Foundation: A Guide to Real-Time Application Architecture

• 0:01:17 - Core vs. Application Separation: The fundamental principle of this architecture is to separate reusable engine code from application-specific code. The "Core" is built as a static library containing foundational systems, while the "App" is the executable that uses the Core to run its unique logic.
• 0:01:46 - What Belongs in the Core: The Core library is responsible for handling reusable components, including the main application system, the windowing system, the event system, the main loop, and core rendering utilities.
• 0:05:55 - The Ideal main Function: The application's entry point (main()) should be extremely simple. Its only jobs are to define the application's initial specifications (like window size and title), create the application instance, add custom functionality via "layers," and run the main loop.
• 0:07:25 - The Layer System for Custom Behavior: "Layers" are the primary mechanism for adding custom functionality. A Layer is a class with virtual functions like onUpdate, onRender, and onEvent. By creating a custom layer (e.g., AppLayer) and pushing it to the application, you can inject your specific update and rendering logic into the main loop without modifying the core engine.
• 0:08:57 - An Example AppLayer: The video demonstrates an AppLayer that handles all the logic for rendering a full-screen fragment shader. The constructor initializes OpenGL resources (shaders, geometry), the destructor releases them, and the onRender method handles the drawing commands each frame.
• 0:11:13 - The Application Class: This central class in the Core library manages the application's lifecycle. It initializes dependencies (like GLFW), creates the window, and contains the main loop. It is often implemented as a singleton for easy global access to application-wide state like window dimensions or time.
• 0:12:48 - The Main Loop Explained: The run() method contains a simple while loop that:
  1. Polls for events (e.g., keyboard input, window closing).
  2. Calculates the delta time since the last frame.
  3. Iterates through all active layers, calling their onUpdate() method.
  4. Iterates through all layers again, calling their onRender() method.
  5. Swaps the window's graphics buffers to display the rendered frame.
• 0:13:54 - Why Separate Update and Render: Even when executed sequentially, separating update logic from rendering logic is crucial. It prepares the architecture for future enhancements like multi-threaded rendering, ensures all game state is updated before any rendering begins, and aids in profiling.