| ►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 |
| 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 |
| 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 |
| 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 |
| ►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 |
| 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 | |
| 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 |
| ►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 |
| 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 |
| 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 |
| 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 |
| CgetByPath_Helper | A helper intended to get scene nodes and related objects attached to the scene tree |
| CgetByPath_Helper< BaseSimObjectAspect & > | |
| CgetByPath_Helper< std::shared_ptr< TObject >, typename std::enable_if_t< std::is_base_of< SceneNodeCore, TObject >::value > > | |
| CgetByPath_Helper< TAspect &, std::enable_if_t< std::is_base_of< BaseSimObjectAspect, TAspect >::value > > | |
| CKey | A private struct to limit certain sensitive functions to this class and other closely coupled classes |
| 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 |
| 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 > > | |
| CSceneSubworld | A subsystem of the SceneSystem which tracks, per world, which objects have had their Placement components updated |
| 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 |
| 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 |
| CLightBoundsComputeSystem | A subsystem of the spatial query system responsible for tracking light volumes and recomputing their ObjectBounds accordingly |
| 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 |
| 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 |
| 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.) |
| 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 |
| CBoard | The data model class representing the 20-square board for Game of Ur |
| CBoardLocations | The aspect responsible for mapping points on the 3D game board to their equivalent coordinates on the game board data model |
| CDice | The data model used to represent the pair of dice used to play Game of Ur |
| CDiceData | Data returned by GameOfUrModel when queried for dice related information |
| CGameOfUrModel | The data model representing one instance of Game of Ur |
| CGamePhaseData | Data returned by GameOfUrModel when queried about the current phase of the game |
| CGamePieceData | Data returned by GameOfUrModel when queried about the state of a single game piece |
| CGameRecord | The details of a single completed game |
| CGameScoreData | Data returned by GameOfUrModel when queried for scores |
| CHouse | The representation of a single house on the Game of Ur Board, in other words a tile |
| CHouseData | Data returned by GameOfUrModel when queried about the state of a House |
| 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) |
| CIUsePointer | The interface used by aspects, objects, which cast pointer rays to interact with objects present in the world |
| CMoveResultData | Data returned by the GameOfUrModel when making a move, or querying possible moves |
| 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 |
| CPiece | The state of a single piece of the game |
| CPieceIdentity | Data uniquely identifying a piece used in the game |
| CPieceType | A struct containing information about a piece, including its name and information |
| CPlayer | Data model for a single player of the game, tracking also the number of counters held by this player |
| CPlayerCPURandom | An aspect representing a computer controlled player of the game of ur, which makes its decisions completely randomly |
| CPlayerData | Data returned by GameOfUrModel when queried about a player |
| CPlayerLocal | Definition of the aspect class representing a player playing the Game of Ur locally |
| CQueryClick | The aspect responsible for conducting raycasts and calling pointer event callbacks on eligible objects |
| CRenderDebugViewer | A utility aspect class used to log window events and change the debug texture rendered to the viewport it manages |
| CTutorialContent | The data associated with a single tutorial page |
| 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 |
| CUrController | The class responsible for managing and reporting the state of the game. It owns its own instance of GameOfUrModel, and acts as the interface between it and engine-specific objects |
| CUrLookAtBoard | Stupid utility class for centering the game camera in the 3D scene on the game board object |
| CUrPieceAnimationKey | |
| CUrPlayerControls | The definition for the object that acts as the interface between the game controller and any systems or objects interested in interacting with it |
| CUrRecords | Class responsible for loading, validating, and storing records of all completed games played on this platform |
| CUrSceneManager | The aspect class responsible for transitioning between the scenes availabe in the game |
| CUrSceneView | The class responsible for managing the 3D representation and interactions of a game in progress |
| CUrUINavigation | The aspect class responsible for connecting the UI in the current scene with the game scene manager. Responds to navigation UI events with scene changes |
| CUrUIRecordsBrowser | The aspect class responsible for managing the records browser, responsible for listing and displaying records for completed games |
| CUrUITutorialsBrowser | The aspect class responsible for loading, listing, and displaying the tutorial pages written for this game |
| CUrUIVersion | The class responsible for setting the game version text of the UI object it is connected to per the value populated in version.h |
| CUrUIView | The aspect class for the UI layer of the game scene |
1.13.2