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

Nstd	STL namespace
Chash< ToyMaker::ActionDefinition >
Chash< ToyMaker::InputCombo >
Chash< ToyMaker::InputFilter >
Chash< ToyMaker::InputSourceDescription >
NToyMaker	Namespace containing all class definitions and functions related to the ToyMaker engine
CActionContext	A container for actions that make sense within a given context
CActionData	A union that may contain any one of SimpleActionData, OneAxisActionData, TwoAxisActionData, ThreeAxisActionData
CActionDefinition	The definition of a single action, including whether it represents state or change, whether it supports negative values, and the number of axes it has
CActionDispatch	An object responsible for tracking action listeners for a given project
CAdditionRenderStage	Stage responsible for combining multiple textures together
CApplication	Class that handles setup for the rest of the engine and application
CgetByPath_Helper	Base template for engine object getter, used by Application::getObject()
CgetByPath_Helper< TObject, typename std::enable_if_t< SceneNodeCore::getByPath_Helper< TObject >::s_valid > >
CAreaCircle	A set of numbers representing a single circle situated somewhere in the world
CAreaTriangle	A set of 3 points located in the world forming a (hopefully sensible) triangle
CAxisAlignedBounds	An object containing a coarse simplified representation, AABB, of spatially queryable objects
CBaseComponentArray	An abstract base class for all ECS component arrays
CBaseConstraint	Base class for constraints
CBaseInstanceAllocator	Class that is responsible for taking an instance layout and correctly uploading it to the GPU
CBaseOffscreenRenderStage	Base class for render stages which render to an offscreen buffer
CBaseRenderStage	Represents a single render stage or a render step that applies to the default (window) framebuffer
CBaseSceneNode	A CRTP template for all the scene node types present in the project
CBaseSimObjectAspect	The base class for all aspects, providing an interface to its attached SimObject, and consequently, the engine's SceneSystem
CBaseSystem	The base class that acts as the interface between the engine's ECS system and a particular built-in or user-defined System
CBlurRenderStage	Multipurpose render stage which at present is used to compute a simple bloom effect from a scene's "brightCutoff" texture
CBuiltinModelMatrixAllocator	An instance allocator initialized with the built in model matrix layout object
CBuiltinVertexData	The vertex data used by all this engine's in-built shader program's vertex shaders
CCameraProperties	Struct that encapsulates properties which define the (geometric) aspects of a scene camera
CCameraSystem	System responsible for managing all active cameras belonging to this world, tracking and updating associated projection and view matrices
CCollision	Data representing everything about a collision
CCollisionPair	Names two distinct entities participating in a collision, with their entity IDs sorted in ascending order
CColorBufferDefinition	A struct containing the definition of a color buffer, using which similar color buffers can be created
CCommonActionData	A struct containing meta-info that will be present for all types of actions
CComponentArray	A class that implements BaseComponentArray specializing it for a component of type TComponent
CComponentFromJSON	A struct that describes how a JSON component description is turned into a component
CComponentFromJSON< std::shared_ptr< TComponent >, Enable >	A specialization of ComponentFromJSON that applies to components that are stored as shared pointers to components (as opposed to a value of the component type itself)
CComponentFromJSON< std::shared_ptr< TResource >, typename std::enable_if< std::is_base_of< IResource, TResource >::value >::type >	Allows a shared pointer to a resource to be constructed as a component for an entity when loading a scene
CComponentManager	An object that stores and manages updates to all the component arrays instantiated for this ECS World
CgetComponentTypeName	Helper function for retrieving the component type string defined as part of the component
CgetComponentTypeName< std::shared_ptr< TComponent > >	A specialization of getComponentTypeName for components which are wrapped in shared pointers
CConstraint	Any constraint storing LagrangeCount correction multipliers
CConstraint1DOFConfig	A collection of values defining an orientation or position constraint for a single degree of freedom
CConstraint1DOFParam	Parameters defining a body participating in a 2-body constraint
CConstraintContact	Constraint requiring exactly two parameters representing colliding rigid bodies
CConstraintContactManifold	Special structure for handling collisions with multiple points of contact accumulated over several timesteps in order to improve stability
CConstraintDampingRigidbody	The velocity constraint responsible for applying a velocity-dependent damping force on all dynamic objects in order to eventually bring them to a stop
CConstraintDistance1D	Constraint where the distance between a pair of points, one from each participant, is restricted along an axis defined relative to participant 0 to a certain range
CConstraintParametrized	Subclass implementation for any constraint which takes data of type TParameter
CConstraintRotation1D	Restricts angle between 2 vectors from 2 participants around an axis defined relative to participant 0 to a certain range
CContact	Object representing contact information between a pair of convex shapes from the perspective of one of those shapes
CECSWorld	A class that represents a set of systems, entities, and components, that are all interrelated, but isolated from other similar sets
CSystemRegistrationArgs	Prevents the use of the unspecialized version of SystemRegistrationArgs
CSystemRegistrationArgs< TSystemDerived, std::tuple< TListenedForComponents... >, std::tuple< TRequiredComponents... > >	The partially specialized version of SystemRegistrationArgs, with its latter 2 template parameters being tuples of components
CEntity	The Entity is a wrapper on an entity ID, used as the primary interface between an application and the engine's ECS system
CFixedActionBinding	A class representing the connection between an Action generated by the InputManager, and a BaseSimObjectAspect method that is interested in handling the action
CFramebuffer	A wrapper class over OpenGL framebuffers
CFramebufferFromDescription	Constructs a Framebuffer from its description in JSON
CGeometryRenderStage	Render step responsible for translating mesh-material data into geometry buffers
CIActionHandler	Class interface for systems that wish to be notified when action events occur in an action context
CIHoverable	The interface implemented by aspects which wish to respond to pointer hover related events
CILeftClickable	The interface used by aspects which wish to respond to mouse left click events (or equivalent)
CInputAttributesType	A class that, perhaps just as unnecessarily, stores a value of InputAttributesValueType
CInputCombo	An input combo that whose value is recorded and mapped to an (axis of an) action value of some kind
CInputFilter	Filter that uniquely defines ONE axis of one control of one input belonging to one device
CInputManager	The class that acts as the main interface between the rest of the project and the input system
CInputSourceDescription	Identifies a single control, such as a button, trigger, or joystick, on a single device
CInstanceAttributeDescriptor	A struct describing the name and type of each attribute designated as an instance attribute
CInstanceLayout	Object representing the layout of one set of related attributes representing (presumably) one object or instance
CInterpolator	A template class for interpolating components between simulation frames for various purposes
CIResource	Base class of all Resource types
CIResourceConstructor	A single way that a resource may be constructed
CIResourceFactory	A class that holds references to all constructors for a type of Resource object
CISignal	The base class for any signal that an object advertises
CISignalObserver
CIUsePointer	The interface used by aspects, objects, which cast pointer rays to interact with objects present in the world
CLightEmissionData	A struct, used as a component, describing the emissive properties of the light it represents per the Blinn-Phong shading model
CLightingRenderStage	Render stage which takes geometry buffers and scene lights as inputs, and produces a lit scene as output
CLightInstanceAllocator	The allocator associated with built in light sources used as attributes
CLightRenderUnit	Contains the model matrix, mesh, and light emission for a single light object being rendered this frame
CMaterial	A collection of key value pairs used to control the behaviour of the rendering system when rendering a single "object."
CMaterialFromDescription	A material resource constructor which converts a material represented in JSON to its Material equivalent
CNineSlicePanel	Resource responsible for resizing a texture using the 9-slice technique, for use in UI elements
CNineSlicePanelFromDescription	Resource constructor for creating new NineSlicePanel resources from their descriptions in JSON
CObjectBounds	A component defining the true bounds of a spatially queryable object situated somewhere in the world
CTrueVolume	A union of supported volume structs
COctree	A data structure used for speeding up spatial queries about 3-dimensional objects in the scene
COctreeNode	A single node of an octree, representing a single octant of the 8 that make up its parent region
COneAxisActionData	Actions that have just one axis of data, eg., the accelerator on a car
COpaqueRenderUnit	An object representing a single opaque mesh-material pair, to be rendered this frame
CPhysicsState	Component representing the physics state of the body it's attached to at some particular point in time
CPhysicsSystem	The physics system, an ECS system that tracks and updates the state of each physics object in the scene according to its properties
CPhysicsStateFull
CCollisionEvent
CCollisionReport
CPlacement	A component representing the position, rotation, and scale of an entity
CPlane	A set of numbers describing a plane situated somewhere in the world
CPolytope	Primitive for EPA algorithm
CFace	Stores the indices of a single face of this polytope
CQueryClick	The aspect responsible for conducting raycasts and calling pointer event callbacks on eligible objects
CRangeMapperLinear	A simple linear interpolation implementation between a fixed input and output range
CRay	A set of numbers describing a ray with its source at some finite point in the world, projected in a direction for some positive length
CRBO	Wrapper class over OpenGL RBOs
CRegistrator	Helper class for registering a class at program startup
CRenderDebugViewer	A utility aspect class used to log window events and change the debug texture rendered to the viewport it manages
CRenderSet	A collection of shaders, render configurations, cameras, and related framebuffers used by a viewport within an ECSWorld
CRenderSystem	The render system for a single ECSWorld, which joins together various RenderStages into a render pipeline for objects present in that world
CLightQueue	A subsystem of the RenderSystem; tracks light objects in this ECSWorld scheduled for rendering at the next render step
COpaqueQueue	A subsystem of the RenderSystem; tracks opaque and alpha-tested models present in this ECSWorld to be rendered at the next render step
CResizeRenderStage	Render stage responsible for resizing a texture to its final intended resolution
CResource	The base class for any type whose creation and storage should be managed by the ResourceDatabase
CResourceConstructor	An object representing one method for creating a resource of a given kind
CResourceDatabase	A database of all Resource types available for this project, and the various ResourceConstructors responsible for making them
CResourceFactory	Tracks pointers to all ResourceConstructors responsible for creating a resource of one type
CSceneFromDescription	Constructs a scene tree (separate from the scene tree) based on its description in JSON
CSceneFromFile	Constructs a scene tree from a file containing its JSON description
CSceneHierarchyData	Component representing hierarchical information related to this entity
CSceneNode	The most basic vanilla flavour of scene node comprised of no more than a name and some components
CSceneNodeCore	The core of a node in the SceneSystem, a set of components and methods overridable or usable by all types of scene nodes
CKey	A private struct to limit certain sensitive functions to this class and other closely coupled classes
CgetByPath_Helper	A helper intended to get scene nodes and related objects attached to the scene tree
CgetByPath_Helper< std::shared_ptr< TObject >, typename std::enable_if_t< std::is_base_of< SceneNodeCore, TObject >::value > >
CgetByPath_Helper< BaseSimObjectAspect & >
CgetByPath_Helper< TAspect &, std::enable_if_t< std::is_base_of< BaseSimObjectAspect, TAspect >::value > >
CSceneNodeFromDescription	Constructs a scene node based on its description in JSON
CSceneSystem	The SceneSystem, a singleton System, responsible for tracking all objects in the scene, computing their Transforms, and maintaining hierarchical relationships between scene nodes
CPlacementUpdateReporter	A subsystem of the SceneSystem which tracks, per world, which objects have had their Placement components updated
CTransformUpdateReporter	A subsystem of the SceneSystem which tracks, per world, which objects have had their Transform components updated
CgetNodeByID_Helper	Helper struct for retrieving nodes based on their UniversalEntityIDs
CgetNodeByID_Helper< TSceneNode, typename std::enable_if_t< std::is_base_of< SceneNodeCore, TSceneNode >::value > >
CScreenRenderStage	Render stage responsible for rendering any texture attached as source to the screen
CShaderProgram	A wrapper over OpenGL's shader programs
CShaderProgramFromFile	Constructs a ShaderProgram from its shader program header, found at a particular path
CSignal	A Signal object, designed to emit signals matching some data signature to be received by all the SignalObservers subscribed to it
CSignal_	A class containing most of the implementation of this engine's Signal concept
CSignalObserver	A SignalObserver object, which can subscribe to Signals matching its data signature and receive signal events from them
CSignalObserver_	A class containing most of the implementation for this engine's SignalObserver concept
CSignalTracker	A signal tracker, the main interface between an object and the signal system
CSimCore	The component associated with the SimSystem
CSimObject	A wrapper on entity that allows objects in the Scene to be scriptable
CSimObjectAspect	An object containing closely related methods and data, and exposing object lifecycle and application event loops to a developer extending it
CSimObjectFromDescription	Constructs a SimObject from its description in JSON
CSimplex	Primitive for GJK algorithm
CSimSystem	The SimSystem is a system responsible for providing scriptability via SimObjects and SimObjectAspects
CSkyboxRenderStage	Uses a skybox texture (i.e a texture with a supported cubemap format) to render a skybox behind geometry in the scene
CSpatialQuerySystem	The spatial query system, an ECS System that tracks and updates spatial query data for objects in the scene, and which exposes spatial query methods
CStaticModelBoundsComputeSystem	A subsystem of the SpatialQuery system which tracks StaticModel objects in the scene and updates the position and shapes of their associated object bounds accordingly
CLightBoundsComputeSystem	A subsystem of the spatial query system responsible for tracking light volumes and recomputing their ObjectBounds accordingly
CStaticMesh	A class whose current main purpose is to store geometry related info, and to upload it to GPU memory when requested
CStaticMeshCuboidDimensions	Constructs a cuboid mesh based on its dimensions
CStaticMeshFromDescription	Creates a static mesh based on its description in JSON
CStaticMeshRectangleDimensions	Constructs a rectangle mesh based on its dimensions
CStaticMeshSphereLatLong	Mesh constructor that creates a spherical mesh using a latitude-longitude method
CStaticModel	This engine's representation of a single unrigged 3D model
CStaticModelCuboidDimensions	Constructs a cuboid mesh based on its dimensions
CStaticModelFromFile	A constructor method for StaticModels that loads such a model from its model file (w/ extensions such as .fbx, .obj, .gltf, and so on)
CStaticModelRectangleDimensions	Constructs a rectangle mesh using the latitude-longitude method
CStaticModelSphereLatLong	Constructs a sphere model using the latitude-longitude method
CSweepPrune	A class designed around finding which pairs of AABBs may be intersecting (so as to limit the number of full collision checks that need be performed)
CObject	Contains the start and end indices of a sweep and prune object in each dimension's edge list
CEdge	Represents the projection of a bounding box along the axis represented by the edge list that this item appears in
CSystem	A system template that disables systems with this form of declaration
CSystem< TSystemDerived, std::tuple< TListenedForComponents... >, std::tuple< TRequiredComponents... > >	The base class for any built-in or user-defined system that would like to be hooked to the engine's event cycle or have access to entities and components
CSystemManager	Holds references to all the systems belonging to this manager's ECSWorld
CTextFont	A wrapper class over SDL_ttf, providing methods to generate text textures from text using a font as a resource
CTextFontFromFile	The ResourceConstructor responsible for loading a TextFont from its file path
CTexture	The class representation of textures on this engine, which are a type of Resource used both within and outside of the engine
CTextureFromColorBufferDefinition	Generates a texture based on its color buffer definition
CTextureFromFile	A resource constructor which loads a texture from a supported image file located via its file path
CThreeAxisActionData	Actions described by 3 axes (I can't think of any examples for this)
CTonemappingRenderStage	Takes lit scene (with bloom if it's used), and produces a tonemapped and gamma corrected version of the scene
CTransform	The transform component, which moves the vertices of a model to their world space coordinates during rendering
CTwoAxisActionData	Actions that have two axes of data. (Pointer locations, movement direction input, pitch+roll, etc.)
CUIButton	A UI component class for creating simple buttons comprised of a resizable panel and some text
CUIImage	The aspect class responsible for displaying an image from a file scaled to some specific dimensions
CUIPanel	UI aspect responsible for managing and rendering a NineSlicePanel texture on the UI
CUIText	An aspect responsible for rendering text textures and displaying them on a surface in the scene
CUnmappedInputValue	An input state that hasn't yet been mapped to its corresponding action
CVertexAttributeDescriptor	The description of a single vertex attribute associated with a vertex layout, giving its size and location id
CVertexLayout	A list of attribute descriptors that together define the layout and size of the vertex they make up in GPU memory
CViewportNode	A type of node capable of and responsible for interacting sensibly with the engine's RenderSystem and ECSWorlds
CRenderConfiguration	A collection of data that specifies the behaviour and properties of the RenderSystem and target texture associated with this viewport
CViewportChildComp_	Comparator used for determining priority of descendant viewports owned by a RenderSet::RenderType::ADDITION viewport
CViewportNodeFromDescription	Constructs a ViewportNode from its description in JSON
CVolume
CVolumeBase_	The base class of all spatial query volumes
CVolumeBox	Holds the parameters describing the spatial query volume of a simple three-dimensionsal box
CVolumeCapsule	Holds the parameters describing the spatial query volume of a simple three-dimensionsal capsule (or pill, or whatever you like)
CVolumeSphere	Holds parameters describing a spherical spatial query volume
CWindowContext	A class providing access to various window management methods and window event Signals