Class List

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

[detail level 1234]

▼Natlas
►Nevent
Ccollision_enter
Ccollision_exit
Ccollision_persisted
Cevent_bus	Event bus that holds the responsibility to reroute events to the subscribers of those particular event
Cjoystick_button
Cjoystick_info
Clistener	Generic event listener of event type UEvent
Cscene_transition	Event to trigger when to transition specific scenes
►Nmemory
►Ndetail
Cis_array_like
Cis_array_like< std::array< T, N > >
Cis_array_like< T[N]>
Crc	A wrapper that contains both the ref_info and the actual object
Cref_info	Control block for reference counting - type erased
Cenable_strong_from_this	CRTP mixin to enable objects to create strong_ptr instances to themselves
Coptional_ptr	Optional, nullable, smart pointer that works with hal::strong_ptr
Cstrong_ptr	A non-nullable strong reference counted pointer
Cstrong_ptr_only_token	A construction token that can only be created by make_strong_ptr
Cweak_ptr	A weak reference to a strong_ptr
►Nphysics	Types are still be filled out. When this is completed to_jph() can be removed
Cbroad_phase_layer_interface	This class is made to control the broadphase layer. Filters can be added to it to create a better and more organized broadphase. Ass well as giving some control to the user on how the broadphase should be organized. This requires dynamic masking however, which is not currently running
Ccontact_event
Ccontact_listener	Implementation of Jolt's contact listener for collisions
Cjolt_config	Used to keep global data for player access and use. Tells how physics bodies should act within a given scene by default
Cjolt_context	Jolt_context is the backend implementation of physics context
Cjolt_settings	Jolt-specific context configurations These are going to be internally integrated to jolt_context
Cmatrix4
Cmatrix4< JPH::Mat44 >
Cobject_layer_pair_filter	This goes into more detailed ways of filtering, where the object collisions may be defined be what the other object is. In this case a static setup allows static object to trigger collision only when it is touched by a dynamic target
Cobject_vs_broadphase_layer	This is used to tell Jolt what can or cannot collide. As of right now the list is static therfore the layers do not need a dynamic set up. This will change when the object layers become user definable
Cphysics_context	The context is the way to interact with specific backend context implementation such as JoltPhysics as our specific implementation-backend
Cphysics_engine	The manager class for all physics engines. Manages the physics contexts and the collision engines
Cquaternion
Cvector3
Cvector3< JPH::Double3 >
Cvector3< JPH::DVec3 >
Cvector3< JPH::Float3 >
Cvector3< JPH::Vec3 >
Cvector4
Cvector4< JPH::Float4 >
Cvector4< JPH::Vec4 >
►Ntag	Specialized namespace tag to use for specifying operations used with flecs in using tags
Ceditor	To indicate which entities are editor-only
Cserialize	To tag entities to serialize through the serializer
►Nui
Cblock
Cdockspace	Dockspace window using imgui
Cmenu_bar_exception
Cmenu_item	UI wrapper around setting up a menu item group
►Nvk
Ccamera_ubo	Going to remove this
Cgeometry_uniform	Material is going to define properties about how a scene object itself gets rendered
Cglobal_ubo	Just for testing purposes for sending this struct over to the shader
Chud_data
Cimgui_context
Cmaterial_uniform	Represents a vulkan specific mateiral to pass in two textures and offset for handling shininess
Cmesh	Mesh class specifically defined with vulkan implementations for specific primitives TODO: Whenever we load in a texture that will be laucnhed asyncronously
Cshader_resource_group	Resource group for loading shader sources that give you back VkShaderModule handles
Csurface_properties
Cvertex_input
Cvk_context	Vulkan-specific implementation that is the backend of the graphics contextd
Cvk_driver	Logical device implementation wrapper around the VkDevice
Cvk_physical_driver	Vulkan-specific implementation wrapper around VkPhysicalDevice
Cvk_renderer	Something to consider for mesh loading
Cvk_swapchain
Cvk_window
Capplication	Single application that gets created by the engine internally
Capplication_settings	Application properties settings for the window
Cbox_collider
Ccapsule_collider
Cconsole_log_manager	Logger for logging messages to stdout on the console
Cdirectional_light
Cexception_block
Cgame_object	Creates a pointer wrapper which extends capabilities of flecs::entity
Cgraphics_context	Graphics API-agnostic that is centralized to the graphics API themselves
Cinterpolation
Cinvalid_access_exception
Clight_scene_ubo
Cmaterial_metadata
Cmath_generic	Generics to specialize to their mathematical definition of matrices types
Cmatrix2
Cmatrix3
Cmatrix4
Cmesh
Cmesh_source	Loads a mesh source
Cperspective_camera	Define a game object to have a perspective camera that can correspond to it
Cphysics_body	Physics body data-driven representative
Cpoint_light
Cpoint_light_ubo
Cprojection_view	TODO: Consider either relocating where this is and how it gets handled
Crender_context	Interface that defines a graphics APi-agnostic renderer
Crenderer
Cscene	Constructs a scene that defines an area where game objects are part of contained within an atlas::world
Cserializer	Serializer is responsible for saving/loading scenes
Csphere_collider
Csystem_registry	System registry acts as a utility for managing creation of game worlds initially
Ctransform
Cvector2	Vector2<T> is to define as a centralized mathematical representation of types such as glm::vec2, but can be defined based to the needs of specific mathematical types
Cvector2< glm::highp_vec2 >
Cvector3	Vector3<T> is to define a centralized wrapper as a mathematical representaiton for communicating vector3 types from frameworks to glm::vec3
Cvector3< glm::highp_vec3 >
Cvector3< JPH::Vec3 >
Cvector4	Vector4<T> is to define a centralized wrapper as a mathematical representaiton for communicating vector3 types from frameworks to glm::vec3
Cvector4< glm::highp_vec4 >
Cwindow	Represent an entire window that lives throughout the entire duration of the application
Cwindow_settings	Settings for specification for atlas::window
Cworld	World represents a larger scope of areas that manages the scene contexts
▼Nstd
Chash<::vk::vertex_input >
▼NYAML
Cconvert< atlas::body_layer >	Custom specialized classes from yaml-cpp to specialize to take in a atlas::body_layer specifically
Cconvert< atlas::body_type >	Custom specialized classes from yaml-cpp to specialize to take in a atlas::body_type specifically
Cconvert< atlas::box_collider >	Custom specialized classes from yaml-cpp to specialize to take in a atlas::box_collider specifically
Cconvert< atlas::capsule_collider >	Custom specialized classes from yaml-cpp to specialize to take in a atlas::capsule_collider specifically
Cconvert< atlas::mesh_source >
Cconvert< atlas::physics_body >	Custom specialized classes from yaml-cpp to specialize to take in a atlas::physics_body specifically
Cconvert< atlas::point_light >
Cconvert< atlas::sphere_collider >	Custom specialized classes from yaml-cpp to specialize to take in a atlas::sphere_collider specifically
Cconvert< glm::vec2 >	Custom specialized classes from yaml-cpp to specialize to take in a glm::vec2 specifically
Cconvert< glm::vec3 >	Custom specialized classes from yaml-cpp to specialize to take in a glm::vec3 specifically
Cconvert< glm::vec4 >	Custom specialized classes from yaml-cpp to specialize to take in a glm::vec4 specifically