Introduction#
The content of this column is from the online course "Fundamentals of 3D Game Engine Architecture and Design" by XuetangX. I have converted it into a text and image version (I personally prefer text tutorials as they are much faster to read), for easy reference.
Original course link: Fundamentals of 3D Game Engine Architecture and Design.
Memory Management and Plugin Mechanism#
Overview of Memory Management and Plugin Mechanism#
Memory Management#
Memory management is one of the underlying and core aspects of an engine. Almost all top-level base classes in the engine are memory allocation classes, so memory management determines the efficiency of the system.
Memory management in the engine can be divided into CPU main memory and GPU video memory based on the objects. It can also be divided into data structure allocation and release, as well as data access based on the operation type.
Third-party standard libraries, such as STL and BOOST, have provided various memory allocation and management for different data structures. Using these standard libraries can simplify the underlying design of game engines. For example, STL abstracts data types as containers and separates data organization from algorithms. The containers mainly include three types: sequence containers (vector, deque, list, etc.), associative containers (map, multimap, set, multiset, etc.), and container adapters (stack, queue, priority_queue, etc.).
Third-party libraries also provide memory allocation protection mechanisms to avoid the misuse of memory pointers and prevent memory leaks, such as shared_ptr, weak_ptr, scoped_ptr, etc.
Dynamic memory allocation refers to allocating memory when it is needed and releasing memory when it is not needed. However, it has a high overhead. Game engines often use custom allocators for dynamic memory allocation, including:
Extensibility#
Requirements for the extensibility of an engine:
Plugin technology:
-
Plugins are independently developed program blocks managed by the system's plugin interface.
-
Plugin-based architecture is a flexible component-based structure.
-
Programs based on plugin interfaces can dynamically invoke multiple plugins without or with minimal modification to the program.
-
Advantages include: clear and concise core engine functionality, low coupling between plugins for easy maintenance and modification, and improved runtime efficiency by selecting plugins based on needs.
-
Design principles for plugin interfaces include: generality, compatibility, stability, testability, and maintainability.
-
Plugin management mechanism: intelligent recognition of plugins, dynamic installation or uninstallation of plugins, automated invocation, management of communication between plugins, initialization and configuration management of plugins.
Implementation Examples of Memory Management and Plugin Mechanism#
Memory Management and Plugin Mechanism in OGRE#
Classification of memory management in OGRE:
SharedPtr in OGRE:
GPU Buffer management in OGRE:
Implementation mechanism of plugins in OGRE:
Plugin class in OGRE:
plugin.cfg in OGRE:
