Class List

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

[detail level 1234]

Nvex
Casset_path	Base wrapper for generic assets. Currently doesnt add any functionality. Its used mainly for custom functionality in editor
Cmesh_asset_path	Specific wrapper for Meshes
Ctexture_asset_path	Specific wrapper for Textures
Caudio_asset_path	Specific wrapper for Audio
CAudioSystem	System responsible for managing audio playback, mixing, and spatialization
CStandaloneAudio
Crgb	Represents an RGB color value. Used mainly for fancy rendering in editor
Crgba	Represents an RGBA color value. Used mainly for fancy rendering in editor
CDebugConsole
CLogEntry
CComponentStorage	Template-based storage container for components of a specific type
CComponentType	Manages unique type IDs for component types in the ECS system
CRegistry	Central registry for managing entities and their components in the ECS system
CIComponentStorage	Abstract base class for component storage implementations
CView	Provides iteration over entities that have all specified component types
Cenvironment	This struct is used to hold all environment settings. eg. shading details or lighting setup
CAudioClip
CAudioSourceComponent
CTransformComponent	Struct containing transform data and methods
CMeshComponent	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
CLightComponent	Struct containing light properties
CFogComponent	Struct containing fog properties
CNameComponent	Struct that simply contains name of the entity. It is used to identify entity and needs to be unique
CCameraComponent	Struct that contains camera properties. Used by build in CameraObject, but needed for any custom one for engine to recognise object as valid CameraObject
CBillboardComponent	A component for rendering a 2D quad that always faces the camera
CCharacterComponent	Character component for player or NPC characters
CComponentRegistry	Registering GameComponents mainly used to load them in SceneManager
CEditorBillboardComponent	A component for rendering a 2D quad that always faces the camera
CPersistentTag	Tag for entities that should persist across scene changes. Like editor camera
CInputBinding	Struct representing an input binding. SDL_Scancode, state and std::function containing the action to be performed
CMouseAxisBinding	Struct representing an axis binding. Axis and std::function containing the action to be performed
CGamepadButtonBinding	Struct for Gamepad Button bindings
CGamepadAxisBinding	Struct for Gamepad Axis bindings (Joysticks/Triggers)
CInputComponent	Component you add to your GameObject to handle input, eg. add input bindings and mouse axis bindings
CParticleGPUData	Structure passed to the GPU containing per-particle rendering data
CParticle	CPU-side representation of a single particle during its lifetime
CParticleEmitterComponent	Component that emits and manages a system of particles
CUiComponent	Struct containing VexUI class
CLifetimeComponent	Destroys the entity after a set amount of time. Useful for temporary effects
COscillatorComponent	Moves an entity back and forth using a sine wave without physics overhead
CTweenComponent	Smoothly interpolates an entity's local position over time
CGameInfo	This struct contains information about the game. like project name and version
CCameraObject	Basic camera object class. it only contains transform and camera components
CFogObject	Premade FogObject class
CGameObject	Its base class for all game objects, eg. Player, Enemy, Weapon. Your Class needs to inherit from it
CGameObjectFactory	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
CLightObject	Premade LightObject class
CModelObject	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
CVulkanFeatures	Holds the status of various Vulkan features
CHardwareInfo	Utility class for retrieving and storing hardware and driver information
CImGUIWrapper	This class provides an interface template for ImGui Implementation. Every backend should implement this class
CInputSystem	Input system class responsible for handling input events and updating input components
CKeyState	Key state structure. Used to track the state of keyboard keys needed forr held state
CVertex	Vertex structure for mesh data
CSubmesh	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
CMeshData	Mesh data structure for loading and managing mesh data
CBodyIDHasher	Hasher for JPH::BodyID
CBPLayerInterfaceImpl	Implementation of JPH::BroadPhaseLayerInterface for the default layer
CObjectVsBroadPhaseLayerFilterImpl	Implementation of JPH::ObjectVsBroadPhaseLayerFilter for the default layer
CObjectLayerPairFilterImpl	Implementation of JPH::ObjectLayerPairFilter for the default layer
CMyActivationListener	Implementation of JPH::BodyActivationListener for the default layer
CCollisionHit	Structure representing a collision hit
CRaycastHit	Structure representing a raycast hit
CPhysicsComponent	Structure representing a physics component
CPhysicsSystem	Representing a physics system
CInterpCache
CMyContactListener
CDebugDrawFilter	Implementation of JPH::BodyDrawFilter for debugging physics bodies
CResolutionManager	Responsible for managing resolution settings, calculating render resolution based on selected mode
CScene	Scene class implements scene functionality like loading and holding game objects
CSceneManager	SceneManager class implements scene management functionality like loading and unloading scenes, holding game objects
CThreadPool
CFlexValue	Lightweight struct to hold parsed sizes safely away from VexUI dependencies
CLayoutNode	Layout node representing a single UI element in the layout tree
CUIVertex	Represents a vertex for a UI element
CUIPushConstants	Push constants for UI rendering
CUIUnitValue	Struct storing unit value logic natively
CUIUnitVec2	2D representation of UIUnitValue to replace glm::vec2 size safely
CFontAtlas	Font atlas structure
CUIStyle	Basic UI styling component
CUIQuad	Quad component needed for rendering
CWidget	Struct defining widget component, it has a lot of redundancy and probably will need cleanup before expanding on a feature
CVexUI	Defining VexUI, it initializes the UI system, loads, renders, converts ui data, essentially managing ui from file to reneering
CVirtualFileSystem	This class provides abstraction of file system needed for loading packed and unpacked assets
CFileData	Simple struct needed to represent loaded file with data and size
CVPKHeader	Struct defining vpak file header data, used to validate file integrity
CVPKFileEntry	Struct defining virtual file "header", used to identify files in the virtual file system
CLoadedVPK	Struct holding data of loaded vpk file
CVPKStream	Class implementing custom file stream functionality for virtual file system. Inherits from std::istream
CVPKStreamBuf
CSkipInit
CEngine	For interaction with engine systems
CVulkanContext	Struct holding all vulkan data, like device, surface, swapchain, images, views, and more
CPlane	Represents a plane in 3D space
CFrustum	Represents a frustum in 3D space
CInterface	Interface Class for vulkan backend
CMeshManager
CDebugVertex	Represents a vertex used for debugging purposes
CVulkanPipeline	A class managing creating vulkan pipelines. Both form meshes and UI elements
CFrustumSoA
CRenderItem	Struct to hold information about a render item
CBillboardItem	Struct to hold information about a billboard render item
CEditorBillboardItem
CBillboardPushData	Struct to hold push data for billboard rendering
CSceneRenderData	Data structure to pass state between render stages
CRenderer	Responsible for rendering the scene using Vulkan backend
CBatchedTextureData	Helper struct for batching texture loading
CVulkanResources	This class manages resources like textures, descriptor sets, and uniform buffers
CVulkanSwapchainManager	Manages Vulkan swapchain resources
CSceneUBO	Scene uniform buffer object. Holds data that is bind once per scene
CLight	Light struct for shader
CSceneLightsUBO	Scene lights uniform buffer object
CPushConstants	Push constants, holds model information
CVulkanImGUIWrapper	With Imgui for vulkan backend definition, inheriting from ImGUIWrapper
CVulkanMesh	Defining mesh object with vulkan specific data and methods
CSubmeshBuffers	Struct used to hold buffers and allocations for each submesh in single object
CTransparentTriangle	Struct used to held transparent triangles data for sorting and special rendering
CLogEntry
CVPKAssimpStream
CVPKAssimpIOSystem
CIgnoreSensorFilter
CWindow	This class esentially abstracts SDL_Window
CBasicCamera
CDialogWindow	A specialized Engine class for creating and managing modal dialog windows
CEditor	The main Editor class, inheriting from Engine and providing editor-specific functionality and UI
CCopiedObjectData
CICommand	Base Command Interface
CTransformCommand	Gizmo Movement Command
CSerializedObject	Serialized object data for recreation on undo
CDeleteCommand	Saves Delete action command
CProjectMetadata	Metadata structure for a recently used project
CProjectSelector	Specialized Engine class for the initial project selection screen
CBrowserIcons	Structure holding texture IDs for various asset types displayed in the browser
CAssetBrowser	Responsible for displaying and navigating project assets within an ImGUI window
CBasicEditorWindow	Defines the structure for a basic, detachable editor window
CEditorCameraObject	A specialized camera object for use within the editor, supporting free-fly movement and input processing
CEditorImGUIWrapper	A specialized ImGUI wrapper for the editor, which customizes initialization for editor features
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
CProjectProperties	Structure to hold all configurable project settings and properties
CProjectVersion
CSceneAction	Structure to define an action to be performed on a scene object outside of the hierarchy drawing loop