(WIP) C++ Reflection System

Code reflection and type information are essential concepts in programming that play a significant role in various software development processes, particularly in the realm of game development and the creation of editors.

Code reflection is the ability of a program to examine and manipulate its own structure, data, and behavior during runtime. It provides developers with the means to inspect classes, methods, fields, and other program elements, as well as to interact with them dynamically. This introspective capability allows for powerful runtime operations like object instantiation, method invocation, and dynamic loading of classes.

In the context of game development, code reflection and type information offer several benefits, particularly when creating custom editors for game content, levels, assets, and more. Here’s how they help:

1. Dynamic Editors: Game development often involves creating custom editors to facilitate the design and manipulation of game content. Reflection allows these editors to inspect the structure of game objects and assets at runtime, providing a dynamic and user-friendly interface for modifying properties and behaviors without recompiling the entire project.
2. Efficient Workflows: By utilizing type information, game developers can build tools that understand the relationships between different types of game data. This knowledge enables the creation of streamlined workflows for content creation, as editors can present relevant options and information based on the context.
3. Modularity and Extensibility: Reflection and type information enable the development of modular systems where new features, components, or assets can be added without extensive manual integration. Editors can discover and present new content automatically, reducing the need for manual configuration.
4. Debugging and Testing: Reflection assists in creating debugging and testing tools that can analyze the state of game objects and assets during runtime. This aids in identifying issues and optimizing performance.
5. Data-Driven Development: Many modern games rely on data-driven development, where game behavior is defined by external data files. Reflection and type information support this approach by allowing editors to parse and validate these data files against the expected structure.

Glassify

Glassify is a simple customizable Header-Only Reflection System for C++. It allows the user to easily reflect upon types wherever they are inside of the codebase. The reflection data is generated before the main function is executed. The developer can choose which data gets stored inside of the reflection system by adding code to the config header files.

Features

• Reflecting Types: Glassify allows for easy reflection of types using a simple Macro: GLAS_TYPE()
• Member Variables: member variables can also be reflected using the macro GLAS_MEMBER()
• Functions and Member Functions can be reflected and called at runtime using the macros GLAS_FUNCTION() GLAS_MEMBER_FUNCTION()
• Serialization: fields can be automatically converted to binary data or formated using the serialization system.
• Instancing any reflected type on the heap at runtime using the Type ID for that type.