Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 12]

▼Ntinyobj
Cattrib_t
Ccallback_t
Cindex_t
Cjoint_and_weight_t
Clines_t
Cmaterial_t
CMaterialFileReader
CMaterialReader
CMaterialStreamReader
Cmesh_t
CObjReader
CObjReaderConfig
Cpoints_t
Cshape_t
Cskin_weight_t
Ctag_t
Ctexture_option_t
CActor	Base class representing an actor in the scene
CAnimatedSpriteRenderComponent	AnimatedSpriteRenderComponent extends SpriteRenderComponent to support frame-based 2D sprite animations using a sequence of textures
CAssetManager	AssetManager is a static utility class responsible for loading, caching, and managing textures and meshes across the application
CBox	Represents an axis-aligned bounding box (AABB) in 3D space. Used primarily for collision detection and spatial calculations
CBoxColliderComponent	BoxColliderComponent represents an axis-aligned bounding box (AABB) collider. It handles collision detection using box geometry and provides debug rendering
CCamera
CColliderComponent	Base class for collider components used in physics and collision detection. Inherits from Component for lifecycle management and DebugRenderInterface for debug visualization
CComponent	Base class for all components that can be attached to an Actor. Components define behavior or functionality and are updated each frame. They can respond to events such as start, update, end, or world transform changes
CDebugRenderInterface
CEditorController
CEngine	Engine is the main class responsible for initializing and running the game. It manages the game loop, rendering, updating the game world, handling input, and managing scenes. The Engine class interacts with the renderer, window, and various game components, ensuring that the game runs efficiently and responds to user input
CIInputListener	Interface for classes that want to receive input events. Classes implementing this interface must handle SDL_Event notifications
CInputEvent	InputEvent is responsible for managing a list of input listeners and broadcasting SDL events to them. Listeners can subscribe or unsubscribe to receive event notifications
CInputManager	Responsible for handling user input events, including keyboard and mouse input. It allows subscribers to register for specific input events (key presses and mouse button events) and notifies them when the events occur
CIRenderer	IRenderer is an abstract base class for rendering systems. It defines methods for initializing, drawing, and managing graphics resources, which must be implemented by specific renderer classes (e.g., OpenGL, SDL)
CLog	Log class provides static methods for logging messages to the SDL log system. It includes functions for printing informational messages and errors with specific categories, using SDL's built-in logging capabilities
CMatrix4	Matrix4 represents a 4x4 matrix used for transformations in 3D space. It supports various operations such as matrix multiplication, inversion, and extracting different transformation components (e.g., translation, rotation, scale). This matrix can also be constructed for specific transformations like scaling, rotating, and translating, as well as for creating projection matrices for rendering
CMesh	Mesh represents a drawable collection of vertices, textures, and shader data. It stores vertex data, manages a vertex array object (VAO), and allows attaching multiple textures. The mesh also supports serialization of vertex data into a flat array for GPU uploading
CMeshComponent	MeshComponent is a renderable component that holds a reference to a Mesh. It is responsible for rendering the mesh using the transform of its owning actor. This component also supports texture selection via index and texture tiling adjustments
CMoveComponent	MoveComponent handles the movement logic for an actor. It applies forces, updates position and rotation, and integrates basic physics like gravity and friction. Also supports collision detection via an optional collider component
CPhysicManager	The PhysicManager is a singleton responsible for managing and detecting collisions between ColliderComponent instances. It allows adding/removing components and performs collision detection between them
CPlayerController
CQuaternion	Quaternion represents a rotation in 3D space using four components (x, y, z, w). It supports construction from axis-angle, Euler angles, or component values, and provides utility functions for normalization, interpolation, and conversion to matrices
CRectangle	Represents a 2D axis-aligned rectangle used for UI, collision detection, or rendering. Supports AABB collision checks and conversion to SDL's rectangle format
CRectangleColliderComponent	RectangleColliderComponent represents a 2D axis-aligned bounding box (AABB) collider. It provides collision detection and debug rendering for rectangular shapes in 2D space
CRectangleRenderComponent	RectangleRenderComponent is a simple render component for drawing a 2D rectangle. It renders in viewport space, making it suitable for UI or overlays
CRenderComponent	RenderComponent is an abstract base class for all components that need to be rendered. It provides hooks for lifecycle events and defines the interface for rendering and draw order
CRendererGL	RendererGL is an OpenGL-based renderer that implements IRenderer. It handles OpenGL initialization, shader loading, and drawing of 2D/3D objects, including sprites, meshes, and textures, using OpenGL API
CRendererSDL	RendererSDL is an SDL-based renderer that implements IRenderer. It manages the SDL rendering context, handles drawing 2D primitives (like rectangles), and textures (like sprites) using SDL's rendering functions
CScene	Base class representing a game scene that manages actors and rendering. Scenes handle actor lifecycles (add, update, remove) and are tied to a specific window and renderer. Derived classes should override Load and Start to define behavior
CShader	Shader is a class representing a shader in OpenGL. It handles the creation, loading, and compilation of shaders from files, including vertex, fragment, tessellation control, tessellation evaluation, and geometry shaders. It provides functionality to retrieve the shader ID and its source code
CShaderProgram	ShaderProgram is a class that represents an OpenGL shader program. It is responsible for managing the compilation, linking, and use of shaders in an OpenGL application. It allows setting uniforms such as floats, vectors, and matrices, as well as determining if tessellation shaders are part of the program
CSpriteRenderComponent	SpriteRenderComponent is responsible for rendering textured 2D sprites. It operates in viewport space and is ideal for UI elements or 2D graphics. Supports draw ordering, flipping, and customizable rectangle dimensions
CTexture	Texture is a wrapper for SDL and OpenGL texture loading, management, and activation. It abstracts differences between SDL and OpenGL renderers for texture creation and usage
CTime	Static utility functions and variables to manage frame timing, delta time computation, frame rate regulation, and tracking the elapsed game time. It is designed to be a singleton-style class with only static members and no instances
CTransform	Transform is a component that defines the position, rotation, and scale of an actor in 3D space. It provides direction vectors, transformation matrix computation, and rotation utility functions
CVector2	A class representing a 2D vector
CVector3	Vector3 is a 3D vector utility class used for position, direction, and math operations in 3D space
CVector4	Vector4 is a 4D vector class used in graphics, math, and color representations. It supports arithmetic, normalization, dot/cross products, and interpolation
CVertex
CVertexArray	VertexArray is a class that encapsulates an OpenGL Vertex Array Object (VAO) and its associated buffers. It handles the creation and management of vertex buffers and index buffers, along with setting up the appropriate vertex attributes for rendering. This class is used to store and manage vertex data in memory for rendering purposes in OpenGL
CWindow	Encapsulates an SDL window used for rendering the game. It handles window creation, access to window dimensions, and cleanup