| Cvex::AssetBrowser | Responsible for displaying and navigating project assets within an ImGUI window |
| Cvex::AudioClip | |
| Cvex::AudioSourceComponent | |
| Cvex::AudioSystem | System responsible for managing audio playback, mixing, and spatialization |
| CBasicEditorWindow | Defines the structure for a basic, detachable editor window |
| Cvex::BatchedTextureData | Helper struct for batching texture loading |
| Cvex::BillboardComponent | A component for rendering a 2D quad that always faces the camera |
| Cvex::BillboardItem | Struct to hold information about a billboard render item |
| Cvex::BillboardPushData | Struct to hold push data for billboard rendering |
| CJPH::BodyActivationListener | |
| Cvex::MyActivationListener | Implementation of JPH::BodyActivationListener for the default layer |
| CJPH::BodyDrawFilter | |
| Cvex::DebugDrawFilter | Implementation of JPH::BodyDrawFilter for debugging physics bodies |
| CJPH::BodyFilter | |
| Cvex::IgnoreSensorFilter | |
| Cvex::BodyIDHasher | Hasher for JPH::BodyID |
| CJPH::BroadPhaseLayerInterface | |
| Cvex::BPLayerInterfaceImpl | Implementation of JPH::BroadPhaseLayerInterface for the default layer |
| Cvex::BrowserIcons | Structure holding texture IDs for various asset types displayed in the browser |
| Cvex::CameraComponent | Struct that contains camera properties. Used by build in CameraObject, but needed for any custom one for engine to recognise object as valid CameraObject |
| Cvex::CharacterComponent | Character component for player or NPC characters |
| Cvex::CollisionHit | Structure representing a collision hit |
| Cvex::ComponentRegistry | Registering GameComponents mainly used to load them in SceneManager |
| Cvex::ComponentType | Manages unique type IDs for component types in the ECS system |
| CJPH::ContactListener | |
| Cvex::MyContactListener | |
| Cvex::Editor::CopiedObjectData | |
| Cvex::DebugConsole | |
| Cvex::DebugVertex | Represents a vertex used for debugging purposes |
| Cvex::EditorBillboardComponent | A component for rendering a 2D quad that always faces the camera |
| Cvex::EditorBillboardItem | |
| CEditorMenuBar | ImGUI component responsible for drawing the main editor menu bar and handling its actions |
| CEditorProperties | Structure to hold all configurable editor settings and properties |
| Cvex::Engine | For interaction with engine systems |
| Cvex::DialogWindow | A specialized Engine class for creating and managing modal dialog windows |
| Cvex::Editor | The main Editor class, inheriting from Engine and providing editor-specific functionality and UI |
| Cvex::ProjectSelector | Specialized Engine class for the initial project selection screen |
| Cvex::environment | This struct is used to hold all environment settings. eg. shading details or lighting setup |
| Cvex::VirtualFileSystem::FileData | Simple struct needed to represent loaded file with data and size |
| Cvex::FlexValue | Lightweight struct to hold parsed sizes safely away from VexUI dependencies |
| Cvex::FogComponent | Struct containing fog properties |
| Cvex::FontAtlas | Font atlas structure |
| Cvex::Frustum | Represents a frustum in 3D space |
| Cvex::FrustumSoA | |
| Cvex::GameInfo | This struct contains information about the game. like project name and version |
| Cvex::GameObject | Its base class for all game objects, eg. Player, Enemy, Weapon. Your Class needs to inherit from it |
| Cvex::BasicCamera | |
| Cvex::CameraObject | Basic camera object class. it only contains transform and camera components |
| CEditorCameraObject | A specialized camera object for use within the editor, supporting free-fly movement and input processing |
| Cvex::FogObject | Premade FogObject class |
| Cvex::LightObject | Premade LightObject class |
| Cvex::ModelObject | ModelObject class represents a model object in the engine. Thanks to engine separation from the backend, its constructor takes more parameters than its allowed by GameObjectFactory, thus it can only be created by Model Creators methods |
| Cvex::GameObjectFactory | Responsible for registering and then creating GameObjects eg. Player, CameraObject. It is needed to load GameObjects from scene files but not all GameObjects can be registered. It requires your GameObject to not change constructor parameters |
| Cvex::GamepadAxisBinding | Struct for Gamepad Axis bindings (Joysticks/Triggers) |
| Cvex::GamepadButtonBinding | Struct for Gamepad Button bindings |
| Cvex::HardwareInfo | Utility class for retrieving and storing hardware and driver information |
| Cvex::ICommand | Base Command Interface |
| Cvex::DeleteCommand | Saves Delete action command |
| Cvex::TransformCommand | Gizmo Movement Command |
| Cvex::IComponentStorage | Abstract base class for component storage implementations |
| Cvex::ComponentStorage< T > | Template-based storage container for components of a specific type |
| Cvex::ImGUIWrapper | This class provides an interface template for ImGui Implementation. Every backend should implement this class |
| Cvex::VulkanImGUIWrapper | With Imgui for vulkan backend definition, inheriting from ImGUIWrapper |
| CEditorImGUIWrapper | A specialized ImGUI wrapper for the editor, which customizes initialization for editor features |
| Cvex::InputBinding | Struct representing an input binding. SDL_Scancode, state and std::function containing the action to be performed |
| Cvex::InputComponent | Component you add to your GameObject to handle input, eg. add input bindings and mouse axis bindings |
| Cvex::InputSystem | Input system class responsible for handling input events and updating input components |
| Cvex::Interface | Interface Class for vulkan backend |
| Cvex::PhysicsSystem::InterpCache | |
| CAssimp::IOStream | |
| Cvex::VPKAssimpStream | |
| CAssimp::IOSystem | |
| Cvex::VPKAssimpIOSystem | |
| Cstd::istream | |
| Cvex::VirtualFileSystem::VPKStream | Class implementing custom file stream functionality for virtual file system. Inherits from std::istream |
| Cvex::InputSystem::KeyState | Key state structure. Used to track the state of keyboard keys needed forr held state |
| Cvex::LayoutNode | Layout node representing a single UI element in the layout tree |
| Cvex::LifetimeComponent | Destroys the entity after a set amount of time. Useful for temporary effects |
| Cvex::Light | Light struct for shader |
| Cvex::LightComponent | Struct containing light properties |
| Cvex::VirtualFileSystem::LoadedVPK | Struct holding data of loaded vpk file |
| Cvex::DebugConsole::LogEntry | |
| Cvex::LogEntry | |
| Cvex::MeshComponent | Struct containing raw meshData, mesh id, texture paths and material properties. It just template and data for rendering backend to load/convert this data to its acceptible format. This is made weirdly cause its made in mind for multiple backends. IDK i hate this system but i have no better idea |
| Cvex::MeshData | Mesh data structure for loading and managing mesh data |
| Cvex::MeshManager | |
| Cvex::MouseAxisBinding | Struct representing an axis binding. Axis and std::function containing the action to be performed |
| Cvex::NameComponent | Struct that simply contains name of the entity. It is used to identify entity and needs to be unique |
| CJPH::ObjectLayerPairFilter | |
| Cvex::ObjectLayerPairFilterImpl | Implementation of JPH::ObjectLayerPairFilter for the default layer |
| CJPH::ObjectVsBroadPhaseLayerFilter | |
| Cvex::ObjectVsBroadPhaseLayerFilterImpl | Implementation of JPH::ObjectVsBroadPhaseLayerFilter for the default layer |
| Cvex::OscillatorComponent | Moves an entity back and forth using a sine wave without physics overhead |
| Cvex::Particle | CPU-side representation of a single particle during its lifetime |
| Cvex::ParticleEmitterComponent | Component that emits and manages a system of particles |
| Cvex::ParticleGPUData | Structure passed to the GPU containing per-particle rendering data |
| Cvex::PersistentTag | Tag for entities that should persist across scene changes. Like editor camera |
| Cvex::PhysicsComponent | Structure representing a physics component |
| Cvex::PhysicsSystem | Representing a physics system |
| Cvex::Plane | Represents a plane in 3D space |
| Cvex::ProjectMetadata | Metadata structure for a recently used project |
| CProjectProperties | Structure to hold all configurable project settings and properties |
| CProjectVersion | |
| Cvex::PushConstants | Push constants, holds model information |
| Cvex::RaycastHit | Structure representing a raycast hit |
| Cvex::Registry | Central registry for managing entities and their components in the ECS system |
| Cvex::Renderer | Responsible for rendering the scene using Vulkan backend |
| Cvex::RenderItem | Struct to hold information about a render item |
| Cvex::ResolutionManager | Responsible for managing resolution settings, calculating render resolution based on selected mode |
| Cvex::Scene | Scene class implements scene functionality like loading and holding game objects |
| CSceneAction | Structure to define an action to be performed on a scene object outside of the hierarchy drawing loop |
| Cvex::SceneLightsUBO | Scene lights uniform buffer object |
| Cvex::SceneManager | SceneManager class implements scene management functionality like loading and unloading scenes, holding game objects |
| Cvex::SceneRenderData | Data structure to pass state between render stages |
| Cvex::SceneUBO | Scene uniform buffer object. Holds data that is bind once per scene |
| Cvex::SerializedObject | Serialized object data for recreation on undo |
| Cvex::SkipInit | |
| Cvex::AudioSystem::StandaloneAudio | |
| Cstd::streambuf | |
| Cvex::VirtualFileSystem::VPKStream::VPKStreamBuf | |
| Cstd::string | |
| Cvex::asset_path | Base wrapper for generic assets. Currently doesnt add any functionality. Its used mainly for custom functionality in editor |
| Cvex::audio_asset_path | Specific wrapper for Audio |
| Cvex::mesh_asset_path | Specific wrapper for Meshes |
| Cvex::texture_asset_path | Specific wrapper for Textures |
| Cvex::Submesh | Submesh structure for mesh data, its made like this cause some file formats hold multiple meshes in one file, but engine supports only one mesh per file |
| Cvex::VulkanMesh::SubmeshBuffers | Struct used to hold buffers and allocations for each submesh in single object |
| Cvex::ThreadPool | |
| Cvex::TransformComponent | Struct containing transform data and methods |
| Cvex::TransparentTriangle | Struct used to held transparent triangles data for sorting and special rendering |
| Cvex::TweenComponent | Smoothly interpolates an entity's local position over time |
| Cvex::UiComponent | Struct containing VexUI class |
| Cvex::UIPushConstants | Push constants for UI rendering |
| Cvex::UIQuad | Quad component needed for rendering |
| Cvex::UIStyle | Basic UI styling component |
| Cvex::UIUnitValue | Struct storing unit value logic natively |
| Cvex::UIUnitVec2 | 2D representation of UIUnitValue to replace glm::vec2 size safely |
| Cvex::UIVertex | Represents a vertex for a UI element |
| Cglm::vec3 | |
| Cvex::rgb | Represents an RGB color value. Used mainly for fancy rendering in editor |
| Cglm::vec4 | |
| Cvex::rgba | Represents an RGBA color value. Used mainly for fancy rendering in editor |
| Cvex::Vertex | Vertex structure for mesh data |
| Cvex::VexUI | Defining VexUI, it initializes the UI system, loads, renders, converts ui data, essentially managing ui from file to reneering |
| Cvex::View< Components > | Provides iteration over entities that have all specified component types |
| Cvex::VirtualFileSystem | This class provides abstraction of file system needed for loading packed and unpacked assets |
| Cvex::VirtualFileSystem::VPKFileEntry | Struct defining virtual file "header", used to identify files in the virtual file system |
| Cvex::VirtualFileSystem::VPKHeader | Struct defining vpak file header data, used to validate file integrity |
| Cvex::VulkanContext | Struct holding all vulkan data, like device, surface, swapchain, images, views, and more |
| Cvex::VulkanFeatures | Holds the status of various Vulkan features |
| Cvex::VulkanMesh | Defining mesh object with vulkan specific data and methods |
| Cvex::VulkanPipeline | A class managing creating vulkan pipelines. Both form meshes and UI elements |
| Cvex::VulkanResources | This class manages resources like textures, descriptor sets, and uniform buffers |
| Cvex::VulkanSwapchainManager | Manages Vulkan swapchain resources |
| Cvex::Widget | Struct defining widget component, it has a lot of redundancy and probably will need cleanup before expanding on a feature |
| Cvex::Window | This class esentially abstracts SDL_Window |
1.16.1 