| CCoreGraphics::__Mesh | |
| CResources::ResourceLoader::_Callbacks | Callback functions to run when an associated resource is loaded (can be stacked) |
| CResources::ResourceLoader::_LoadMetaData | |
| CResources::ResourceLoader::_PendingResourceLoad | Struct for pending resources which are about to be loaded |
| CResources::ResourceLoader::_PendingResourceUnload | |
| CResources::ResourceLoader::_PendingStreamLod | Struct for pending stream |
| CVulkan::VkShaderServer::_PendingView | |
| CVulkan::VkShaderServer::_PendingViewDelete | |
| CResources::ResourceLoader::_PlaceholderResource | |
| CUtil::_smallvector< TYPE, STACK_SIZE > | |
| CUtil::_smallvector< TYPE, 0 > | |
| CResources::ResourceLoader::_StreamData | |
| CCoreGraphics::AccelerationStructureBarrierInfo | |
| CAccessMode | |
| CPhysics::Actor | |
| CPhysics::ActorContext | |
| CPhysics::ActorId | |
| CPhysics::ActorInfo | |
| CPhysics::ActorResourceId | |
| CCoreGraphics::Adapter | Display adapter enum |
| CCoreGraphics::AdapterInfo | Contains information about a given display adapter |
| CGame::World::AddStagedComponentCommand | |
| CNavigation::AgentContext | |
| CPhysics::Aggregate | |
| CPhysics::AggregateContext | |
| CPhysics::AggregateId | |
| CPhysics::AggregateInfo | |
| CPhysics::AggregateResourceId | |
| CCoreGraphics::Alloc | |
| CGame::World::AllocateInstanceCommand | |
| CUtil::AllocatorLock< T > | |
| CCoreGraphics::AllocRange | |
| CMath::AngularPFeedbackLoop | A proportional feedback loop with correct angular interpolation |
| CCoreAnimation::AnimationCreateInfo | |
| CCoreAnimation::AnimationId | |
| CCoreAnimation::AnimationResourceId | |
| CCharacters::CharacterContext::AnimationRuntime | |
| CCharacters::CharacterContext::AnimationTracks | |
| CCoreAnimation::AnimClip | An animation clip is a collection of related animation curves (for instance all curves required to animate a character) |
| CCoreAnimation::AnimCurve | An animation curve describes a set of animation keys in an AnimKeyBuffer |
| CCoreAnimation::AnimEvent | An animation event associates a name with a point in time |
| CCoreAnimation::AnimEventEmitter | The AnimEventEmitter collects all animevents which are active in the given time range |
| CAnimation::AnimEventInfo | The AnimEventInfo has extra information of the animevent, like the animjob from which it is initiated |
| CAnimation::AnimJobEnqueueMode | Describes the behaviour when enqueueing a new animation job into an anim sequencer |
| CAnimResource | A AnimResource is a collection of related animation clips (for instance all animation clips of a character) |
| CCoreAnimation::AnimSampleBuffer | Stores the result of an animation sampling operation, stores samples key values and sample-counts which keep track of the number of samples which contributed to a mixing result (this is necessary for correct mixing of partial animations) |
| CCoreAnimation::AnimSampleMask | |
| CCoreAnimation::AnimSampleMixInfo | A data structure for providing sample/mixing attributes to asynchronous jobs in the CoreAnimation subsystem |
| CAnimation::AnimSequencer | An AnimSequencer object arranges AnimJobs along the time line to produce a single, priority-blended result |
| CCoreAnimation::AnimUtil | A class which contains utility methods for animation sampling and mixing |
| CCoreGraphics::AntiAliasQuality | Anti-alias quality levels |
| CIm3d::AppData | |
| CNebulaEngine.AppEntry | |
| CAppLauncher | Launch an external application |
| CApp::Application | Provides a simple application model for Nebula apps |
| CApp::ConsoleApplication | Base class for Nebula console applications |
| CApp::GameApplication | Nebula's default game application |
| CApp::RenderApplication | Render application class with multithreaded rendering |
| CApp::ViewerApplication | Derived from RenderApplication, adds support for Stages, Views and GraphicsEntities to the asynchronous render app |
| CArchive | Wrapper class for a platform-specific file archive |
| CArchiveFileSystem | Top-level platform wrapper class of archive file systems |
| CArchiveFileSystemBase | Base class for archive file system wrappers |
| CLighting::LightContext::AreaLightSetupInfo | |
| CMemory::ArenaAllocator< ChunkSize > | Allocates memory in chunks |
| CUtil::Array< TYPE, SMALL_VECTOR_SIZE > | Nebula's dynamic array class |
| CUtil::PinnedArray< MAX_ALLOCS, TYPE > | |
| CUtil::TrivialArray< TYPE > | Array class based on Util::Array for trivial and POD types that avoids any per element copying and constructor/destructor calls |
| CUtil::Array< const MaterialTemplatesGPULang::Entry * > | |
| CUtil::PinnedArray< 0xFFFF, const MaterialTemplatesGPULang::Entry * > | |
| CUtil::Array< CoreGraphics::MeshId > | |
| CUtil::PinnedArray< 0xFFFF, CoreGraphics::MeshId > | |
| CUtil::Array< CoreGraphics::PrimitiveGroup > | |
| CUtil::PinnedArray< 0xFFFF, CoreGraphics::PrimitiveGroup > | |
| CUtil::Array< float > | |
| CUtil::PinnedArray< 0xFFFF, float > | |
| CUtil::Array< IndexT > | |
| CUtil::PinnedArray< 0xFFFF, IndexT > | |
| CUtil::Array< INTERFACE_TYPE > | |
| CUtil::PinnedArray< 0xFFFF, INTERFACE_TYPE > | |
| CUtil::Array< Materials::MaterialId > | |
| CUtil::PinnedArray< 0xFFFF, Materials::MaterialId > | |
| CUtil::Array< Math::bbox > | |
| CUtil::PinnedArray< 0xFFFF, Math::bbox > | |
| CUtil::Array< Math::mat4 > | |
| CUtil::PinnedArray< 0xFFFF, Math::mat4 > | |
| CUtil::Array< Models::ModelContext::NodeInstanceState > | |
| CUtil::PinnedArray< 0xFFFF, Models::ModelContext::NodeInstanceState > | |
| CUtil::Array< Models::ModelNode * > | |
| CUtil::PinnedArray< 0xFFFF, Models::ModelNode * > | |
| CUtil::Array< Models::NodeType > | |
| CUtil::PinnedArray< 0xFFFF, Models::NodeType > | |
| CUtil::Array< NodeInstanceFlags > | |
| CUtil::PinnedArray< 0xFFFF, NodeInstanceFlags > | |
| CUtil::Array< Threading::ThreadId > | |
| CUtil::PinnedArray< MAX_ALLOCS, Threading::ThreadId > | |
| CUtil::PinnedArray< 0xFFFF, Threading::ThreadId > | |
| CUtil::Array< uint32_t > | |
| CUtil::PinnedArray< 0xFFFF, uint32_t > | |
| CUtil::Array< uint64_t > | |
| CUtil::PinnedArray< 0xFFFF, uint64_t > | |
| CUtil::Array< Util::Tuple< float, float > > | |
| CUtil::PinnedArray< 0xFFFF, Util::Tuple< float, float > > | |
| CUtil::Array< Util::Tuple< uint32_t, uint32_t > > | |
| CUtil::PinnedArray< 0xFFFF, Util::Tuple< uint32_t, uint32_t > > | |
| CUtil::Array< void * > | |
| CUtil::PinnedArray< 0xFFFF, void * > | |
| CUtil::ArrayAllocator< TYPES > | The ArrayAllocator provides a variadic list of types which is to be contained in the allocator and fetching each value by providing the index into the list of types, which means the members are nameless |
| CUtil::ArrayAllocator< TYPES... > | |
| CIds::IdAllocator< CrowdAgentId, int, NavMeshId, Math::point > | |
| CIds::IdAllocator< Util::StringAtom, Util::FixedArray< Ptr< JobThread > >, uint > | |
| CIds::IdAllocator< CreateJobInfo, std::function< void()>, PrivateMemory > | |
| CIds::IdAllocator< std::function< void()>, Threading::Event *, std::atomic_uint *, bool > | |
| CIds::IdAllocator< SkeletonId, CoreAnimation::AnimationId, LoadState, AnimationTracks, Timing::Time, Util::FixedArray< Math::mat4 >, Util::FixedArray< Math::mat4 >, Util::FixedArray< Math::mat4 >, Util::FixedArray< SkeletonJobJoint >, CoreAnimation::AnimSampleBuffer, bool, Graphics::GraphicsEntityId, IndexT > | |
| CIds::IdAllocator< Util::FixedArray< CharacterJoint >, Util::FixedArray< Math::mat4 >, Util::HashTable< Util::StringAtom, IndexT >, Util::FixedArray< Math::vec4 > > | |
| CIds::IdAllocator< Util::FixedArray< SkeletonId > > | |
| CIds::IdAllocator< Util::FixedArray< AnimClip >, Util::FixedArray< AnimCurve >, Util::FixedArray< AnimEvent >, Util::HashTable< Util::StringAtom, IndexT, 32 >, Ptr< AnimKeyBuffer > > | |
| CIds::IdAllocator< Util::FixedArray< AnimationId > > | |
| CIds::IdAllocator< GLFWwindow *, CoreGraphics::DisplayMode, IndexT, WindowCreateInfo, ResizeInfo, SwapchainId, void * > | |
| CIds::IdAllocator< ImageLoadInfo > | |
| CIds::IdAllocator< Util::FixedArray< MeshId >, CoreGraphics::VertexAlloc, CoreGraphics::VertexAlloc > | |
| CIds::IdAllocator< VkBarrierInfo, Util::Array< CoreGraphics::TextureId > > | |
| CIds::IdAllocator< VkDevice, VkCommandPool > | |
| CIds::IdAllocator< VkDevice, VkEventInfo > | |
| CIds::IdAllocator< VkDevice, VkFenceInfo > | |
| CIds::IdAllocator< VkPassLoadInfo, VkPassRuntimeInfo, VkRenderPassBeginInfo, Util::Array< uint32_t > > | |
| CIds::IdAllocator< Util::FixedArray< VkRenderingAttachmentInfo >, VkRenderingAttachmentInfo, VkRenderingInfo, VkPipelineRenderingCreateInfo, VkPipelineViewportStateCreateInfo, Util::FixedArray< VkFormat >, RenderPassShaderInterface, SizeT > | |
| CIds::IdAllocator< VkDevice, VkDescriptorSet, IndexT, Threading::Spinlock, CoreGraphics::ResourceTableLayoutId, Util::HashTable< uint64_t, WriteInfo >, Util::Array< VkCopyDescriptorSet, 4 > > | |
| CIds::IdAllocator< VkDevice, VkDescriptorSetLayout, Util::Array< VkDescriptorPoolSize >, Util::Array< Util::Pair< CoreGraphics::SamplerId, uint32_t > >, Util::HashTable< uint32_t, bool >, Util::Array< VkDescriptorPool >, Util::Array< uint > > | |
| CIds::IdAllocator< VkDevice, VkPipelineLayout > | |
| CIds::IdAllocator< VkDevice, VkSampler, uint32_t > | |
| CIds::IdAllocator< VkDevice, VkSemaphore, CoreGraphics::SemaphoreType, uint64_t > | |
| CIds::IdAllocator< VkReflectionInfo, VkShaderSetupInfo, VkShaderRuntimeInfo, Util::Array< CoreGraphics::ShaderProgramId > > | |
| CIds::IdAllocator< VkShaderProgramSetupInfo, VkProgramReflectionInfo, VkShaderProgramRuntimeInfo > | |
| CIds::IdAllocator< VkDevice, VkSurfaceKHR, VkSwapchainKHR, uint, Util::FixedArray< CoreGraphics::SemaphoreId >, Util::FixedArray< CoreGraphics::SemaphoreId >, CoreGraphics::DisplayMode, Util::Array< VkImage >, Util::Array< VkImageView >, VkQueue, CoreGraphics::QueueType, CoreGraphics::CmdBufferPoolId > | |
| CIds::IdAllocator< VkTextureViewLoadInfo, VkTextureViewRuntimeInfo > | |
| CIds::IdAllocator< Util::HashTable< uint64_t, DerivativeLayout >, VkPipelineVertexInputStateCreateInfo, BindInfo, CoreGraphics::VertexLayoutInfo, Util::Array< SizeT >, VertexLayoutVkBindInfo > | |
| CIds::IdAllocator< Math::mat4, DecalType, Ids::Id32, Graphics::StageMask > | |
| CIds::IdAllocator< Resources::ResourceId, Resources::ResourceId, Resources::ResourceId > | |
| CIds::IdAllocator< Resources::ResourceId > | |
| CIds::IdAllocator< FogVolumeType, Ids::Id32, float, Math::vec3, Graphics::StageMask > | |
| CIds::IdAllocator< Math::mat4 > | |
| CIds::IdAllocator< Math::vec3, float > | |
| CIds::IdAllocator< Volume > | |
| CIds::IdAllocator< Graphics::CameraSettings, Math::mat4, Math::mat4, Math::mat4, Graphics::StageMask > | |
| CIds::IdAllocator< Shared::ViewConstants::STRUCT, Shared::ShadowViewConstants::STRUCT, CoreGraphics::TextureId, Math::rectangle< int >, Graphics::StageMask, bool(*)(const Math::rectangle< int > &viewport, IndexT frameIndex, IndexT bufferIndex), GraphicsEntityId, bool > | |
| CIds::IdAllocator< Graphics::GraphicsEntityId, LightType, Math::vec3, float, bool, float, Ids::Id32, Graphics::StageMask > | |
| CIds::IdAllocator< Math::transform44, CoreGraphics::TextureId, std::array< Graphics::GraphicsEntityId, 6 >, std::array< Math::rectangle< int >, 6 >, std::array< Math::mat4, 6 > > | |
| CIds::IdAllocator< Math::transform44, std::array< float, 2 >, CoreGraphics::TextureId, Math::mat4, Math::mat4, Math::rectangle< int >, Graphics::GraphicsEntityId > | |
| CIds::IdAllocator< Math::transform44, AreaLightShape, bool, std::array< Graphics::GraphicsEntityId, 2 >, std::array< Math::mat4, 2 >, std::array< Math::rectangle< int >, 2 >, bool > | |
| CIds::IdAllocator< Graphics::ViewId, Math::vector, Math::mat4, Util::FixedArray< Graphics::GraphicsEntityId >, Util::FixedArray< Math::rectangle< int > >, Util::FixedArray< float >, Util::FixedArray< Math::mat4 > > | |
| CIds::IdAllocator< Math::mat4, Math::mat4 > | |
| CIds::IdAllocator< Util::StringAtom, float, Util::Array< Resources::ResourceId >, Util::FixedArray< CoreGraphics::ResourceTableId >, CoreGraphics::BufferId, Util::FixedArray< Util::FixedArray< CoreGraphics::ResourceTableId > >, Util::FixedArray< Util::Tuple< IndexT, SizeT > >, Util::FixedArray< Util::Array< MaterialTexture > >, Util::FixedArray< Util::Array< MaterialConstant > >, IndexT, const MaterialTemplatesGPULang::Entry * > | |
| CIds::IdAllocator< uint > | |
| CIds::IdAllocator< Math::bbox, Util::Array< Models::ModelNode * > > | |
| CIds::IdAllocator< Resources::ResourceId, Util::Array< uint32_t >, NodeInstanceRange, NodeInstanceRange, Util::Dictionary< Util::StringAtom, IndexT >, Math::mat4, Graphics::StageMask, bool > | |
| CIds::IdAllocator< Particles::ParticleResourceId, Util::Array< ParticleSystemRuntime >, Graphics::ContextEntityId, ParticleRuntime, Graphics::GraphicsEntityId > | |
| CIds::IdAllocator< Memory::RangeAllocation, Raytracing::UpdateType, uint, Util::FixedArray< CoreGraphics::BlasId > > | |
| CIds::IdAllocator< TerrainLoadInfo, TerrainRuntimeInfo, TerrainInstanceInfo > | |
| CIds::IdAllocator< BiomeSettings > | |
| CIds::IdAllocator< CoreGraphics::TextureId, CoreGraphics::TextureId, CoreGraphics::TextureId, CoreGraphics::TextureId, CoreGraphics::MeshId, uint, IndexT, float, float, VegetationType > | |
| CIds::IdAllocator< bool, Graphics::GraphicsEntityId, VisibilityEntityType, Graphics::StageMask, VisibilityResultArray, VisibilityDrawList, Memory::ArenaAllocator< 1024 >, Util::FixedArray< uint64_t >, Util::FixedArray< Math::ClipStatus::Type > > | |
| CIds::IdAllocator< Graphics::GraphicsEntityId, uint32_t > | |
| CIds::IdAllocator< Audio::ClipId, Math::point, Math::vector, float, float, float, float, bool, float > | |
| CIds::IdAllocator< SoLoud::Wav, uint > | |
| CIds::IdAllocator< TYPES > | An ID allocator associates an id with a slice in an N number of arrays |
| CUtil::ArrayAllocatorSafe< MAX_ALLOCS, TYPES > | The ArrayAllocatorSafe provides a thread safe variadic list of types which is to be contained in the allocator and fetching each value by providing the index into the list of types, which means the members are nameless |
| CUtil::ArrayAllocatorSafe< MAX_ALLOCS, TYPES... > | |
| CIds::IdAllocatorSafe< 0xFFFF, Resources::ResourceName, __Mesh > | |
| CIds::IdAllocatorSafe< 0xFFF, VkDevice, VkAccelerationStructureKHR, CoreGraphics::BufferId, CoreGraphics::BufferId, GeometrySetup, VkDeviceAddress > | |
| CIds::IdAllocatorSafe< 0xFFFF, VkAccelerationStructureInstanceKHR, Math::mat4, uint > | |
| CIds::IdAllocatorSafe< 0xFFF, VkDevice, SceneSetup, VkAccelerationStructureKHR, CoreGraphics::BufferId, CoreGraphics::BufferId, CoreGraphics::BufferId, VkDeviceAddress, VkDeviceAddress > | |
| CIds::IdAllocatorSafe< 0xFFFF, VkBufferLoadInfo, VkBufferRuntimeInfo, VkBufferMapInfo > | |
| CIds::IdAllocatorSafe< 0xFF, BufferSparsePageTable, Util::Array< VkSparseMemoryBind > > | |
| CIds::IdAllocatorSafe< 0x1000, VkDevice, VkCommandBuffer, VkCommandPool, CoreGraphics::CmdPipelineBuildBits, VkPipelineBundle, ViewportBundle, ScissorBundle, CoreGraphics::QueueType > | |
| CIds::IdAllocatorSafe< 0xFFFF, VkTextureRuntimeInfo, VkTextureLoadInfo, VkTextureMappingInfo > | |
| CIds::IdAllocatorSafe< 0xFFFF, CoreGraphics::TextureViewId, IndexT > | |
| CIds::IdAllocatorSafe< 0xFF, VkTextureSwapInfo > | |
| CIds::IdAllocatorSafe< 0xFF, TextureSparsePageTable, VkSparseImageMemoryRequirements, Util::Array< VkSparseMemoryBind >, Util::Array< VkSparseImageMemoryBind >, Util::Array< CoreGraphics::Alloc > > | |
| CIds::IdAllocatorSafe< 0xFFFF, ParticleEmitters > | |
| CIds::IdAllocatorSafe< 0xff, Util::StringAtom, dtNavMesh *, dtNavMeshQuery *, NavMeshT > | |
| CIds::IdAllocatorSafe< 0xFFFF, Physics::ActorInfo > | |
| CIds::IdAllocatorSafe< 0xFFFF, Physics::ConstraintInfo > | |
| CIds::IdAllocatorSafe< 0xFFFF, Physics::AggregateInfo > | |
| CIds::IdAllocatorSafe< 0xFFFF, PhysicsResource::PhysicsResourceUnion, Ids::Id32 > | |
| CIds::IdAllocatorSafe< MAX_ALLOCS, TYPES > | |
| CUtil::ArrayQueue< TYPE > | |
| CUtil::ArrayStack< TYPE, STACK_SIZE > | Nebula's small vector optimized array |
| CScripting::NSharpServer::Assembly | |
| CScripting::AssemblyId | |
| CThreading::AssertingMutex | |
| CThreading::AssertingScope | |
| CThreading::Interlocked::AtomicInt | |
| CThreading::Interlocked::AtomicInt64 | |
| CThreading::Interlocked::AtomicPointer | |
| CMemDb::Attribute | |
| CGame::ComponentInterface | These are registered to the attribute registry so that we can add more functionality to attributes |
| CAttr::AttributeContainer | A simple container for attributes |
| CAttr::AttributeDefinitionBase | Implements a universal attribute definition, consisting of an attribute name, attribute fourcc code, value type and access type |
| CAttr::AttributeDefinition< VALUETYPE, TYPE > | This extends the typeless AttributeDefinitionBase class by a typed template class, which adds compiletime-type-safety to attribute definitions |
| CMemDb::AttributeId | |
| CMemDb::AttributeRegistry | |
| CAttr::AttrId | An attribute ID is used to carry attribute types (no values) around |
| CAttr::BlobAttrId | Typed attribute id for blob type |
| CAttr::BoolAttrId | Typed attribute id for bool type |
| CAttr::FloatAttrId | Typed attribute id for float type |
| CAttr::GuidAttrId | Typed attribute id for guid type |
| CAttr::Int64AttrId | |
| CAttr::IntAttrId | Typed attribute id for integer type |
| CAttr::Mat4AttrId | Typed attribute id for mat4 type |
| CAttr::StringAttrId | Typed attribute id for string type |
| CAttr::UIntAttrId | Typed attribute id for unsigned integer type |
| CAttr::Vec4AttrId | Typed attribute id for vec4 type |
| CAudio::AudioEmitterId | |
| CBarrier | Implements the 2 macros ReadWriteBarrier and MemoryBarrier |
| CCoreGraphics::BarrierContext | |
| CCoreGraphics::BarrierCreateInfo | |
| CCoreGraphics::BarrierId | |
| CCoreGraphics::BarrierScope | |
| CCoreGraphics::BarrierStackEntry | |
| CMultiplayer::BaseMultiplayerClient | |
| CMultiplayer::StandardMultiplayerClient | |
| CMultiplayer::BaseMultiplayerServer | |
| CMultiplayer::StandardMultiplayerServer | |
| CVulkan::VkPipelineDatabase::BaseNode | |
| CVulkan::VkPipelineDatabase::Tier1Node | |
| CVulkan::VkPipelineDatabase::Tier2Node | |
| CVulkan::VkPipelineDatabase::Tier3Node | |
| CVulkan::VkPipelineDatabase::Tier4Node | |
| CCoreGraphics::BaseVertex | |
| CGame::FrameEvent::Batch | A batch of frame callbacks |
| CMath::bbox | Nebula's bounding box class |
| CMath::BezierCubic< POINT > | |
| CVulkan::BindInfo | |
| CBindlessRegistry | Handles binding of bindless resources |
| CGraphics::BindlessRegistryCreateInfo | |
| CMemory::RangeAllocator::BinIndex | |
| CTerrain::BiomeMaterial | |
| CTerrain::BiomeMaterialBuilder | |
| CTerrain::BiomeParameters | |
| CTerrain::BiomeSettings | |
| CTerrain::BiomeSettingsBuilder | |
| CUtil::BitField< NUMBITS > | Implements large bit field |
| CUtil::BitField< NUMBITS >::BitType< S > | |
| CUtil::BitField< NUMBITS >::BitType< 16 > | |
| CUtil::BitField< NUMBITS >::BitType< 32 > | |
| CUtil::BitField< NUMBITS >::BitType< 64 > | |
| CCoreGraphics::BlasCreateInfo | |
| CCoreGraphics::BlasId | |
| CCoreGraphics::BlasInstanceCreateInfo | |
| CCoreGraphics::BlasInstanceId | |
| CUtil::Blob | The Util::Blob class encapsulates a chunk of raw memory into a C++ object which can be copied, compared and hashed |
| CAttr::BlobArrayTypeClass | |
| CAttr::BlobTypeClass | |
| CGame::BlueprintManager::Blueprint | Entity blueprint |
| CGame::BlueprintId | |
| CPhysics::BodyInfo | |
| CAttr::BoolArrayTypeClass | |
| CParticles::EmitterAttrs::BoolAttributes | |
| CAttr::BoolTypeClass | |
| CPhysics::CharacterCreateInfo::BoxInfo | |
| CVisibility::BoxSystemLoadInfo | |
| CVisibility::BruteforceSystemLoadInfo | |
| CCoreGraphics::BufferBarrier | |
| CCoreGraphics::BufferBarrierInfo | |
| CCoreGraphics::BufferCopy | |
| CCoreGraphics::BufferCreateInfo | |
| CFrame::FrameOp::BufferDependency | |
| CCoreGraphics::BufferId | |
| CVulkan::BufferMapping | |
| CCoreGraphics::BufferSet | Set of buffers which creates a buffer per each buffered frame |
| CBufferSetup | Types used for buffers, how they are created and their intended usage |
| CCoreGraphics::BufferSparsePage | |
| CVulkan::BufferSparsePageTable | |
| CFrame::FrameOp::BufferSubresourceDep | |
| CCoreGraphics::BufferSubresourceInfo | |
| CCoreGraphics::BufferWithStaging | |
| CFrame::FrameOp::BuildContext | |
| CBase::GamePadBase::ButtonState | |
| CBase::MouseBase::ButtonState | |
| CBvh | A generic bounding volume (AABB) hierarchy |
| CUtil::Bvh | |
| CIO::BXMLFileAttr | |
| CIO::BXMLFileHeader | |
| CIO::BXMLFileNode | |
| CIO::BXmlLoaderUtil | Helper class for loading binary xml files created with N3's binaryxmlconverter3 tool |
| CMath::byte4 | |
| CMath::byte4u | |
| CByteOrder | (C) 2007 Radon Labs GmbH (C) 2013-2018 Individual contributors, see AUTHORS file |
| CSystem::ByteOrder | Provides information and methods to help with byte ordering issues |
| CAttr::ByteTypeClass | |
| CIO::StreamCache::CacheEntry | |
| CTerrain::TextureTileCache::CacheResult | |
| CCalendarTime | Allows to obtain the current point in time as year, month, day, etc... down to milliseconds, convert between filetime and CalendarTime, and format the time to a human readable string |
| CBase::CalendarTimeBase | Allows to obtain the current point in time as year, month, day, etc... down to milliseconds, convert between filetime and CalendarTime, and format the time to a human readable string |
| CPosix::PosixCalendarTime | Posix implementation of CalendarTime |
| CWin32::Win32CalendarTime | Win implementation of CalendarTime |
| CJobs2::CallableStub< ARGS > | |
| CJobs2::CallableStub< ARGS... > | |
| CJobs2::Callable< LAMBDA, ARGS > | |
| CGraphics::CameraSettings | |
| CCameraSettings | Helper class for handling camera projection and related settings |
| CIm3d::Capsule | |
| CPhysics::CharacterCreateInfo::CapsuleInfo | |
| CPhysics::Character | |
| CPhysics::CharacterContext | |
| CPhysics::CharacterCreateInfo | |
| CPhysics::CharacterId | |
| CCharacters::CharacterJobContext | |
| CCharacters::CharacterJoint | |
| CCharacterMaterialSkinNode | A model node that handles materials for characters |
| CCharacterNode | Wraps a Character object into a ModelNode for rendering |
| CMultiplayer::ClientConnection | |
| CMultiplayer::ClientProcessorContext | |
| CAudio::ClipId | |
| CAudio::ClipInstanceId | |
| CMath::ClipStatus | The result of a clip check (Inside, Outside or Clipped) |
| CCoreGraphics::CmdBufferBeginInfo | |
| CCoreGraphics::CmdBufferClearInfo | |
| CCoreGraphics::CmdBufferCreateInfo | |
| CCoreGraphics::CmdBufferId | |
| CCoreGraphics::CmdBufferMarkerBundle | |
| CCoreGraphics::CmdBufferPoolCreateInfo | |
| CCoreGraphics::CmdBufferPoolId | |
| CIm3d::Color | |
| CDb::Column | Describes a column in a database table |
| CMemDb::ColumnIndex | Column id |
| CAttr::AttributeTable::ColumnInfo | |
| CVegetation::CombinedMeshVertex | |
| CCoreGraphics::DrawThread::Command | |
| CCoreGraphics::DrawThread::CommandBuffer | |
| CVulkan::CommandBufferPools | |
| CUtil::CommandLineArgs | A universal cmd line argument parser |
| CFrame::FrameOp::Compiled | |
| CFrame::FrameBarrier::CompiledImpl | |
| CFrame::FrameBlit::CompiledImpl | |
| CFrame::FrameCode::CompiledImpl | |
| CFrame::FrameCompute::CompiledImpl | |
| CFrame::FrameCopy::CompiledImpl | |
| CFrame::FrameMipmap::CompiledImpl | |
| CFrame::FramePass::CompiledImpl | |
| CFrame::FramePlugin::CompiledImpl | |
| CFrame::FrameResolve::CompiledImpl | |
| CFrame::FrameSubgraph::CompiledImpl | |
| CFrame::FrameSubmission::CompiledImpl | |
| CFrame::FrameSubpass::CompiledImpl | |
| CFrame::FrameSubpassBatch::CompiledImpl | |
| CFrame::FrameSubpassFullscreenEffect::CompiledImpl | |
| CFrame::FrameSubpassOrderedBatch::CompiledImpl | |
| CFrame::FrameSubpassPlugin::CompiledImpl | |
| CFrame::FrameSwap::CompiledImpl | |
| Ccompletion_t | |
| CGame::ComponentDecayBuffer | Contains data for components flagged with COMPONENTFLAG_DECAY, that has been deleted this frame |
| CGame::BlueprintManager::ComponentEntry | |
| CGame::ComponentInspection | Component inspection functions |
| CNebula.Game.ComponentManager | |
| CGame::ComponentRegisterInfo< COMPONENT_TYPE > | Used for registering component types to the game world |
| CGame::FilterBuilder::ComponentRequest | |
| CGame::ComponentSerialization | Component serialization functions |
| CIm3d::internal::CompositeT | |
| CIm3d::internal::MatT | |
| CIm3d::internal::VecT | |
| CHttp::HttpClientRegistry::Connection | |
| CConsoleHook.ConsoleEvents | |
| CLighting::LightContext::ConstantBufferSet | |
| CVulkan::GraphicsDeviceState::ConstantsRingBuffer | |
| CPhysics::Constraint | |
| CPhysics::ConstraintId | |
| CPhysics::ConstraintInfo | |
| CPhysics::ConstraintResourceId | |
| CPhysics::ContactEvent | |
| CIm3d::Context | |
| CGraphics::ContextEntityId | |
| Ccore | Basic type definitions for Nebula |
| CSystem::Cpu | Provides information about the system's CPU(s) |
| CUtil::Crc | Compute CRC checksums over a range of memory |
| CJobs::CreateJobInfo | |
| CJobs::CreateJobPortInfo | |
| CJobs::CreateJobSyncInfo | |
| CThreading::CriticalScope | |
| CCriticalSection | Critical section objects are used to protect a portion of code from parallel execution |
| CNavigation::CrowdAgentId | |
| CCoreAnimation::CurveType | Describes the general data type of the keys stored in an animation curve |
| CCore::CVar | A console variable |
| CCore::CVarCreateInfo | Used to create a Core::CVar |
| CCore::CVarValue | |
| CDarwinBarrier | Implements the 2 macros ReadWriteBarrier and MemoryBarrier |
| CDarwin::DarwinTimer | Darwin implementation of the Time::Timer class |
| CGame::Dataset | A dataset that contains views into category tables |
| CMemDb::Dataset | |
| CGI::DDGIOptions | |
| CGame::World::DeallocInstanceCommand | |
| CNebula.Debug | |
| CPhysics::DebugDrawInterface | |
| CDebug::DebugFloat | This class is supposed to make it easier, to restore the exact value of floating- point-based types, like vector, mat4, float etc |
| CUtil::GlobalStringAtomTable::DebugInfo | Debug functionality: DebugInfo struct |
| CNet::DebugMessage | Encapsulates a stream and a port number for debug communication |
| CNet::DebugPacket | Encapsulates a data packet for debug communication |
| CPhysics::DebugState | |
| CUtil::Delegate< T > | Nebula delegate class, allows to store a function, method or lambda call into a C++ object for later execution |
| CVulkan::VkDeferredCommand::Delegate | |
| CUtil::Delegate< RETTYPE(ARGTYPES...)> | |
| CMessaging::DelegateTable | Associates message ids with handler delegates |
| CCoreGraphics::DepthStencilClear | |
| CBase::DepthStencilTargetBase | |
| CVulkan::VkDepthStencilTarget | |
| CVulkan::DerivativeLayout | |
| CCoreGraphics::DerivativeStateId | |
| CVulkan::DescriptorSetBinding | |
| Cnanobind::detail::dict_caster | |
| Cnanobind::detail::type_caster< Util::Dictionary< Key, Value > > | |
| CUtil::Dictionary< KEYTYPE, VALUETYPE > | A collection of key/value pairs with quick value retrieval by key at roughly O(log n) |
| CLighting::LightContext::DirectionalLightSetupInfo | |
| CDisplayDevice | A DisplayDevice object represents the display where the RenderDevice presents the rendered frame |
| CCoreGraphics::DisplayEvent | Display events are sent by the display device to registered display event handlers |
| CCoreGraphics::DisplayMode | Describe a fullscreen display mode or window dimensions |
| CScripting::DotNET_API | |
| CAttr::DoubleTypeClass | |
| CRenderUtil::DrawFullScreenQuad | Actually draws one big triangle which covers the entire screen, which is more efficient than drawing a quad using two triangles |
| CIm3d::DrawList | |
| CModels::ShaderStateNode::DrawPacket | |
| CCoreGraphics::DrawThreadResult | |
| CduDebugDraw | |
| CNavigation::DebugDraw | |
| CGame::EditorState | |
| CUtil::PriorityArray< TYPE >::Element | Element class |
| CParticles::EmitterAttrs | A container for particle emitter attributes |
| CParticles::EmitterMesh | An emitter mesh holds positions and normals for particle emission |
| CParticles::EmitterMesh::EmitterPoint | |
| CGame::Entity | An entity is essentially just an Id with some utility functions attached |
| CNebula.Game.Entity | Represents a game object that resides in a game world |
| CTiXmlBase::Entity | |
| CVisibility::VisibilitySystem::Entity | |
| CGame::EntityCreateInfo | |
| CGame::PackedLevel::EntityGroup | |
| CNebula.Game.EntityId | |
| CGame::EntityMapping | Maps an entity to a table and instance id |
| CGame::EntityPool | Generation pool |
| CGame::EntityTableCreateInfo | |
| CNebula.Game.EntityTemplate | |
| CCoreGraphics::RayDispatchTable::Entry | |
| CMaterialTemplates::Entry | |
| CMaterialTemplatesGPULang::Entry | |
| CTerrain::TileCacheEntry::Entry | |
| CParticles::EnvelopeCurve | An Attack/Sustain/Release envelope curve class with optional sine/cosine modulation |
| CParticles::EnvelopeSampleBuffer | A lookup table for pre-sampled envelope curves |
| CEnvironment | Provides read-access to environment variables |
| CEvent | |
| CThreading::EventWithManualReset | |
| CEventArgs | |
| CConsoleHook.ConsoleWriterEventArgs | |
| CCoreGraphics::EventCreateInfo | |
| CIO::EventHandlerData | |
| CCoreGraphics::EventId | |
| CCore::ExitHandler | ExitHandlers are static objects which register themselves automatically once at startup and are called back from the Core::SysFunc::Exit() static method which is called right before a Nebula application exists |
| CApp::GameApplication::GameAppExitHandler | |
| CAttr::AttrExitHandler | Exit handler for the Attr subsystem, cleans up dynamic attribute definitions before shutdown |
| CMath::Extrapolator< TYPE > | Extrapolator maintains state about updates for remote entities, and will generate smooth guesses about where those entities will be based on previously received data |
| CCore::Factory | Provides the central object factory mechanism for Nebula |
| CCoreGraphics::GraphicsDeviceCreateInfo::Features | |
| CCoreGraphics::FenceCreateInfo | |
| CFenceCreateInfo | A fence is a CPU-GPU sync object, used to let the CPU wait for the GPU to finish some work |
| CCoreGraphics::FenceId | |
| CFibers::Fiber | |
| CFibers::fiber_ctx_t | |
| CFibers::fiber_t | |
| CFibers::FiberContext | |
| CFibers::FiberQueue | |
| CFibers::FiberQueueCreateInfo | |
| CFibers::FiberWaitContext | |
| CFileDialog | Wrapper around NFD for showing file dialogs |
| CFileTime | Defines a file-access timestamp |
| CFileWatcher | Linux implementation of filewatcher |
| CFileWatcher | Win32 implementation of filewatcher |
| CIO::FileWatcherImpl | |
| CIO::FileWatcherPlatform | |
| CGame::FilterBuilder | |
| CGame::FilterBuilder::FilterCreateInfo | |
| CMemDb::FilterSet | |
| CFilterset | Used to query a database |
| CCoreGraphics::MeshLoader::FinishedMesh | |
| CUtil::FixedArray< TYPE, StackAlloc > | Implements a fixed size one-dimensional array |
| CUtil::FixedPool< TYPE > | Implements a fixed size pool, from which objects of a specific type can be allocated and freed for reuse |
| CUtil::FixedTable< TYPE > | A fixed-size 2-dimensional array |
| CFlat::FlatbufferInterface | |
| CMath::half::Float | |
| CMath::float2 | |
| CAttr::Float2ArrayTypeClass | |
| CAttr::Float2TypeClass | |
| CMath::float3 | |
| CMath::float4 | |
| CAttr::Float4ArrayTypeClass | |
| CAttr::Float4TypeClass | |
| CAttr::FloatArrayTypeClass | |
| CAttr::FloatTypeClass | |
| CVulkan::GraphicsDeviceState::ConstantsRingBuffer::FlushedRanges | |
| CUtil::FourCC | A four-character-code is a quasi-human-readable 32-bit-id |
| CModels::CharacterSkinNode::Fragment | Skin fragment |
| CFrame::FrameBatchType | Frame batch type hints for the render device and render targets |
| CFrameBuilder | |
| CGraphics::FrameContext | |
| CGame::FrameEvent | |
| CFrame::FrameOp | |
| CFrame::FrameBarrier | |
| CFrame::FrameBlit | |
| CFrame::FrameCode | |
| CFrame::FrameCompute | |
| CFrame::FrameCopy | |
| CFrame::FrameEvent | |
| CFrame::FrameMipmap | |
| CFrame::FramePass | |
| CFrame::FramePlugin | |
| CFrame::FrameResolve | |
| CFrame::FrameSubgraph | |
| CFrame::FrameSubmission | |
| CFrame::FrameSubpass | |
| CFrame::FrameSubpassBatch | |
| CFrame::FrameSubpassFullscreenEffect | |
| CFrame::FrameSubpassOrderedBatch | |
| CFrame::FrameSubpassPlugin | |
| CFrame::FrameSwap | |
| CGame::FramePipeline | |
| CDebug::FrameScriptInspector | |
| CFrame::FrameScriptLoader | |
| CRenderUtil::FreeCameraUtil | Implements a free camera |
| CMath::frustum | Defines a clipping frustum made of 6 planes |
| CFSWrapper | This is an internal IO class used to wrap platform specific filesystem access into a generic class |
| CGameContentServer | The game content server initializes access to game content on console platforms |
| CGamePad | An input handler which represents a game pad |
| CGcc::GccInterlocked | Provides simple atomic operations on shared variables using gcc compiler builtins |
| CBase::GenericMemoryPool | A simple thread-safe memory pool |
| CRenderUtil::Geometry | |
| CStaticUI::UltralightRenderer::GeometryHandle | |
| CRenderUtil::GeometryHelpers | |
| CVulkan::GeometrySetup | |
| CUtil::get_template_type< C > | |
| CUtil::get_template_type< C< I, T > & > | Get inner type of two types |
| CUtil::get_template_type< C< I, T > > | Get inner type of two types |
| CUtil::get_template_type< C< T > > | Get inner type of two types |
| CUtil::get_template_type< C< T, I > & > | Get inner type of two types |
| CUtil::get_template_type< C< T, I > > | Get inner type of two types |
| CUtil::get_template_type< const C< T > & > | Get inner type of a constant ref outer type |
| CGLFWDisplayDevice | GLFW based OpenGL implementation of DisplayDevice class |
| CGLFWInputServer | Glfw-specific InputServer (provides a default Keyboard and Mouse) |
| CCoreGraphics::Gliml | |
| CGlobalConstants | Management place for global constants, such as those in the tick/frame groups |
| CGraphics::GlobalConstantsCreateInfo | |
| Cultralight::GPUDriver | |
| CStaticUI::UltralightRenderer | |
| CCoreGraphics::GPULangShaderCreateInfo | |
| CDynui::Graph | Time Graph with predefined amount of entries |
| CGraphics::GraphicsContext | |
| CCharacters::CharacterContext | Assumes control over the character animation functionalities of a model if it contains a character definition and an animation set |
| CClustering::ClusterContext | |
| CDecals::DecalContext | |
| CDynui::ImguiContext | |
| CFog::VolumetricFogContext | |
| CGI::DDGIContext | |
| CGraphics::CameraContext | Handles cameras |
| CGraphics::EnvironmentContext | The environment context deals with anything related to the sky and atmosphere effects |
| CGraphics::LightProbeContext | Adds a light probe component to graphics entities |
| CIm3d::Im3dContext | |
| CLighting::LightContext | |
| CModels::ModelContext | |
| CParticles::ParticleContext | |
| CPostEffects::BloomContext | |
| CPostEffects::DownsamplingContext | |
| CPostEffects::HistogramContext | |
| CPostEffects::SSAOContext | |
| CPostEffects::SSRContext | |
| CRaytracing::RaytracingContext | |
| CStaticUI::StaticUIContext | |
| CTBUI::TBUIContext | |
| CTerrain::TerrainContext | |
| CVegetation::VegetationContext | |
| CVisibility::ObservableContext | |
| CVisibility::ObserverContext | |
| CGraphics::GraphicsContextFunctionBundle | |
| CGraphics::GraphicsContextState | A graphics context is a resource which holds a contextual representation for a graphics entity |
| CCoreGraphics::GraphicsDeviceCreateInfo | |
| CCoreGraphics::GraphicsDeviceState | |
| CVulkan::GraphicsDeviceState | |
| CCoreGraphics::GraphicsDeviceThreadState | |
| CGraphics::GraphicsEntityId | The graphics entity is only an Id, to which we can attach GraphicsContexts |
| CVegetation::GrassVertex | |
| CGuid | Implements a GUID |
| CAttr::GuidArrayTypeClass | |
| CAttr::GuidTypeClass | |
| CMath::half | |
| CHash | Generic hash function class based on murmurhash3 |
| CUtil::HashTable< KEYTYPE, VALUETYPE, TABLE_SIZE, STACK_SIZE > | Organizes key/value pairs by a hash code |
| CHeap | Implements a private heap |
| CHttp::HtmlElement | HTML markup elements |
| CHttpClient | Use a HTTP client to send HTTP requests to a HTTP server, and receive and decode HTTP responses |
| CHttp::HttpMethod | Http methods enumeration (GET, PUT, etc...) |
| CHttp::HttpStatus | HTTP status code enumeration (e.g |
| CICustomMarshaler | |
| CUtil.StringMarshaler | |
| CIds::Id | This class implements some static helper functions to set high and low 32-bit integers, as well as a function to create a complete id from two of them |
| CMessaging::Id | A message identifier |
| CIds::IdGenerationPool | Provides a system for creating array friendly id numbers with reuse and generations |
| CIds::IdPool | |
| CIEquatable | |
| CMathf.BoundingBox | |
| CMathf.BoundingFrustum | Defines a viewing frustum for intersection operations |
| CMathf.BoundingSphere | Describes a sphere in 3D-space for bounding operations |
| CMathf.Color | Describes a 32-bit packed color |
| CMathf.Matrix | Represents the right-handed 4x4 floating point matrix, which can store translation, scale and rotation information |
| CMathf.Plane | |
| CMathf.Point | Describes a 2D-point |
| CMathf.Quaternion | An efficient mathematical representation for three dimensional rotations |
| CMathf.Ray | |
| CMathf.Rectangle | Describes a 2D-rectangle |
| CMathf.Vector2 | Describes a 2D-vector |
| CMathf.Vector3 | Describes a 3D-vector |
| CMathf.Vector4 | Describes a 4D-vector |
| CIm3dContext | Nebula renderer for Im3d gizmos |
| CIm3d::Im3dState | |
| CCoreGraphics::ImageCreateInfoData | |
| CCoreGraphics::ImageCreateInfoFile | |
| CCoreGraphics::ImageLoadInfo::ImageData | |
| CCoreGraphics::ImageDimensions | |
| CCoreGraphics::ImageFileFormat | Image file formats supported by StreamTextureSaver |
| CCoreGraphics::ImageId | |
| CCoreGraphics::ImageLoadInfo | |
| CImguiRenderer | Nebula renderer for the IMGUI dynamic UI library |
| CImguiRTPlugin | Use this class to integrate Imgui with the Nebula rendering loop |
| CDynui::ImGuiSecondaryWindowData | |
| CDynui::ImguiState | |
| CDynui::ImguiTextureId | |
| CDynui::ImGuiWindowHandle | |
| CVulkan::VkShapeRenderer::IndexedDraws | |
| CCoreGraphics::IndexType | Data type of vertex indices (16 bit or 32 bit) |
| CTerrain::IndirectionEntry | |
| CNebula.Game.INebulaApi | |
| CNebula.Game.NebulaApiV1 | |
| CCoreAnimation::InfinityType | Describes how time position outsides of an animation curve's scope are handled |
| CCoreGraphics::InputAssemblyKey | |
| CInput::InputEvent | The input events of the Input subsystems |
| CInput::InputPriority | Input priorities for input handlers |
| CInstanceRenderer | The instance renderer performs actual rendering and updating of shader variables for transforms |
| CInstanceRendererBase | Base class for instance renderers |
| CInstanceServer | The instance server collects all instances of a model and render each node instanced, so as to decrease draw calls when rendering huge amounts of identical objects |
| CInstanceServerBase | Instancing interface server base |
| CVulkan::InstanceSetup | |
| CMath::int2 | |
| CMath::int3 | |
| CMath::int4 | |
| CAttr::Int64TypeClass | |
| CAttr::IntArrayTypeClass | |
| CParticles::EmitterAttrs::IntAttributes | |
| CInterface | Implements the asynchronous interface to the IO subsystem |
| CInterlocked | Provide simple atomic operations on memory variables |
| CCoreAnimation::AnimKeyBuffer::Interval | |
| CMemory::RingAllocator< SYNCPOINTS >::Interval | |
| CAttr::IntTypeClass | |
| CIO::IOStat | |
| CIpAddress | Represents an IP address, consisting of a IPv4 host address and a port number |
| CUtil::HashTable< KEYTYPE, VALUETYPE, TABLE_SIZE, STACK_SIZE >::Iterator | |
| CUtil::List< TYPE >::Iterator | List iterator |
| CFibers::FiberQueue::Job | |
| CJobs2::JobContext | |
| CJobs::JobContext | |
| CJobs::JobFuncContext | This class describes the size of a workload for a single thread (can be multiple items) |
| CJobs::JobId | |
| CJobs::JobIOData | |
| CJobs2::JobNode | |
| CJobs::JobPortId | |
| CJobs2::Jobs2Context | |
| CJobs::JobSyncId | |
| CJobs2::JobSystemInitInfo | |
| CJobs::JobThread::JobThreadCommand | |
| CJobs::JobUniformData | |
| CInput::Key | Define standard key codes |
| CKeyboard | An input handler which represents a keyboard for polling |
| CBase::KeyboardBase::KeyState | |
| CUtil::KeyValuePair< KEYTYPE, VALUETYPE > | Key/Value pair objects are used by most assiociative container classes, like Dictionary or HashTable |
| CUtil::KeyValuePair< AttrId, Util::Variant > | |
| CAttr::Attribute | A compiletime-typesafe key/value pair |
| CUtil::KeyValuePair< Util::String, Util::String > | |
| CIO::Assign | An assign associates an intuitive name with a real-world filesystem path |
| CJobs2::Lambda | |
| CBase::Library | Base class for loading and handling dynamic libraries |
| CWin32::Win32Library | Load and handle an external DLL |
| CLibrary | Use to load dynamic libraries and their addresses |
| CIm3d::Line | |
| CMath::line | A line in 3d space |
| CIm3d::LineSegment | |
| CLinux::LinuxCompletionCounter | Block a thread until count reaches 0 |
| CLinux::LinuxEvent | Linux implementation of Event |
| CLinux::LinuxRendezvous | A thread barrier for 2 threads using semaphores |
| CLinuxThreadId | A thread id uniquely identifies a thread within the process |
| CLinux::LinuxThreadLocalData | Thread local data storage class for platforms which don't have a proper __thread implementation but a pthread implementation |
| CLinux::LinuxThreadLocalPtr | A thread-local pointer class for platforms which don't have proper support for the __thread keyword |
| CUtil::List< TYPE > | Implements a doubly linked list |
| CUtil::List< RefCounted * > | |
| CCore::RefCountedList | Implements a static list which keeps track of all refcounted objects to detect refcounting leaks at application shutdown |
| Clist_caster | |
| Cnanobind::detail::type_caster< Util::Array< Type > > | |
| CAudio::AudioDevice::Listener | |
| CListExt | |
| CModels::PrimitiveNode::LoadContext | |
| CResources::ResourceLoader::LoadState | |
| CThreading::LockFreeQueue< TYPE > | |
| CDynui::ImguiConsole::LogEntry | |
| Cultralight::Logger | |
| CStaticUI::Logger | |
| CIm3d::Mat3 | |
| CIm3d::Mat4 | |
| CMath::mat4 | A 4x4 single point precision float matrix |
| CPhysics::Material | |
| CMaterials::MaterialBuffer< INTERFACE_TYPE > | |
| CMaterials::MaterialConstant | |
| CMaterials::MaterialId | |
| CModels::ModelContext::MaterialInstanceContext | |
| CMaterials::MaterialInstanceId | |
| CMaterialTemplates::MaterialTemplateTexture | |
| CMaterialTemplatesGPULang::MaterialTemplateTexture | |
| CMaterialTemplates::MaterialTemplateValue | |
| CMaterialTemplatesGPULang::MaterialTemplateValue | |
| CMaterials::MaterialTexture | |
| CMaterials::MaterialVariant | |
| CMathf.MathHelper | Contains commonly used precalculated values and mathematical operations |
| CAttr::Matrix44ArrayTypeClass | |
| CAttr::Matrix44TypeClass | |
| CRenderUtil::MayaCameraUtil | Helper class to implement a "Maya camera" with pan/zoom/orbit |
| CIO::MediaType | Encapsulates a MIME conformant media type description (text/plain, image/jpg, etc...) |
| CCoreGraphics::MemoryHeap | |
| CCoreGraphics::MemoryPool | |
| CMemoryPool | A simple thread-safe memory pool |
| CCoreGraphics::MeshCreateInfo | |
| CCoreGraphics::MeshLoader::MeshesToSubmit | |
| CCoreGraphics::MeshId | |
| CCoreGraphics::MeshResource | |
| CCoreGraphics::MeshResourceId | |
| CCoreGraphics::MeshLoader::MeshStreamData | |
| CGame::Message< MSG, TYPES > | |
| CMessaging::MessageCallbackHandler | Handles asynchronous message callbacks |
| CGame::MessageListener | |
| CGame::MessageListenerId | |
| CGame::Message< MSG, TYPES >::MessageQueueId | |
| CMiniDump | Support for generating mini dumps |
| CCoreGraphics::TextureLoader::MipHandoverLoaderThread | |
| CCoreGraphics::TextureLoader::MipLoadMainThread | |
| CModels::ModelCreateInfo | |
| CModels::ModelId | |
| CModels::ModelContext::ModelInstance | |
| CModels::ModelNode | |
| CModels::TransformNode | |
| CModels::CharacterNode | |
| CModels::ShaderStateNode | |
| CModels::ParticleSystemNode | |
| CModels::PrimitiveNode | |
| CModels::CharacterSkinNode | |
| CModels::ModelStreamingData | |
| CCoreGraphics::Monitor | |
| CInput::MouseButton | Mouse button codes and conversion from/to string |
| CRenderUtil::MouseRayUtil | Helper class to compute a world-space ray from mouse coords |
| CNebula.Game.Msg | |
| CNebula.Game.MsgDispatcher | |
| CNebula.Game.MsgDispatcher.MsgEvent | |
| CNebula.Game.NativeComponent | All structs that inherit from this class will automatically be registered and searchable as native components |
| CNavigation::NavMeshId | |
| CCoreAnimation::Nax2Curve | |
| CCoreAnimation::Nax2Group | |
| CCoreAnimation::Nax2Header | Legacy NAX2 file format structs |
| CCoreAnimation::Nax3Anim | |
| CCoreAnimation::Nax3AnimEvent | |
| CCoreAnimation::Nax3Clip | |
| CCoreAnimation::Nax3Curve | |
| CCoreAnimation::Nax3Header | NAX3 file format structs |
| CCoreAnimation::Nax3Interval | |
| CNebula.Game.NebulaApp | |
| CNebulaSettings | Platform independent way for storing persistent settings Will use registry in windows and config files on other platforms |
| CTerrain::OccupancyQuadTree::Node | |
| CTerrain::TextureTileCache::Node | |
| CThreading::LockFreeQueue< TYPE >::Node | |
| CUtil::Bvh::Node | |
| CUtil::List< TYPE >::Node | Node in the list |
| CUtil::OccupancyQuadTree::Node | |
| CUtil::QuadTree< TYPE >::Node | Node in quad tree |
| CUtil::SimpleTree< VALUETYPE >::Node | Public node class |
| CModels::NodeInstanceRange | |
| CModels::ModelContext::NodeInstanceState | |
| CRenderUtil::NodeLookupUtil | Helper class to find specific nodes and nodeinstances inside a graphicsentity |
| CMath::noise | Perlin noise class |
| CCoreGraphics::NormalVertex | |
| CCoreGraphics::ColorVertex | |
| CCoreGraphics::SecondUVVertex | |
| CCoreGraphics::SkinVertex | |
| CCharacters::Nsk3Header | NSK3 file format structs |
| CCharacters::Nsk3Joint | |
| CCharacters::Nsk3Skeleton | |
| Cstd::numeric_limits< Math::half > | |
| CCoreGraphics::Nvx2Group | |
| CCoreGraphics::Nvx2Header | NVX2 file format structs |
| CNvx2StreamReader | A stream reader which reads legacy nvx2 binary mesh files |
| CCoreGraphics::Nvx3Elements | |
| CCoreGraphics::Nvx3Group | |
| CCoreGraphics::Nvx3Header | NVX3 file format structs |
| CCoreGraphics::Nvx3Meshlet | |
| CNvx3StreamReader | A stream reader which reads legacy nvx3 binary mesh files |
| CCoreGraphics::Nvx3VertexRange | |
| CVisibility::VisibilitySystem::Observer | |
| CTerrain::OccupancyQuadTree | |
| CUtil::OccupancyQuadTree | |
| CVisibility::OctreeSystemLoadInfo | |
| COSX::OSXCpu | CPU related definitions for the MacOSX platform |
| COSX::OSXCriticalSection | On OSX, pthread mutexes are used for critical sections |
| COSX::OSXFileTime | Wraps file-system related timestamps on OSX |
| COSX::OSXFSWrapper | Internal filesystem wrapper for the OSX |
| COSX::OSXGuid | OSX implementation of the Util::Guid class |
| COSX::OSXHeap | OSX implementation of Memory::Heap |
| COSX::OSXMemoryPool | FIXME: IMPLEMENT ME! |
| COSXThreadId | A thread id uniquely identifies a thread within the process |
| COSX::OSXThreadLocalPtr< TYPE > | GCC doesn't implement the __thread modifier on OSX |
| CGame::PackedLevel | Represents a level that can be instantiated into a world |
| CWin32::ParentWindow | |
| CParticles::Particle | The particle structure holds the current state of a single particle and common data for particle-job and nebula3 particle system |
| CParticles::ParticleEmitters | |
| CParticles::ParticleJobContext | |
| CParticles::ParticleContext::ParticleJobOutput | |
| CParticles::ParticleJobSliceOutputData | |
| CParticles::ParticleJobUniformData | |
| CParticleRenderInfo | ParticleRenderInfo objects are returned by the ParticleRenderer singleton when a visible particle system is attached |
| CParticles::ParticleResourceId | |
| CParticles::ParticleContext::ParticleRuntime | |
| CParticleSystemMaterialNode | The ParticleSystemNode wraps a ParticleSystem object into a ModelNode for rendering using materials |
| CParticles::ParticleContext::ParticleSystemRuntime | |
| CMemDb::Table::Partition | Represents a partition within a Table in MemDb |
| CPass | A pass describe a set of textures used for rendering |
| CMaterialTemplates::Entry::Pass | |
| CMaterialTemplatesGPULang::Entry::Pass | |
| CCoreGraphics::PassCreateInfo | |
| CCoreGraphics::PassId | |
| CVulkan::GraphicsDeviceState::PendingDeletes | |
| CVulkan::GraphicsDeviceState::PendingMarkers | |
| CHttp::HttpServer::PendingRequest | |
| CMath::PFeedbackLoop< TYPE > | A P feedback loop (proportional feedback loop) is a simple object which moves a system's current state towards a goal, using the resulting error (difference between goal and state as feedback on the next run |
| CTerrain::PhysicalTileUpdate | |
| CPhysicsInterface | |
| CPhysics::PhysicsResourceId | |
| CMath::PIDFeedbackLoop | A PID feedback loop (proportional integral derivative feedback loop) |
| CNavigationFeature::NavigationManager::Pids | |
| CCoreGraphics::PinnedBuffer< STORAGE > | |
| CVulkan::Pipeline | |
| CCoreGraphics::PipelineCreateInfo | |
| CCoreGraphics::PipelineId | |
| CCoreGraphics::PipelineRayTracingTable | |
| CCoreGraphics::PixelFormat | Pixel format enumeration |
| CIm3d::Plane | |
| CMath::plane | A mathematical plane represented by a normal and a distance from origin |
| CMathf.PlaneHelper | |
| CMath::point | Represents a 3D point in space |
| CLighting::LightContext::PointLightSetupInfo | |
| CMath::polar | A polar coordinate inline class, consisting of 2 angles theta (latitude) and rho (longitude) |
| CMemory::PoolArrayAllocator | Allocates small memory blocks from an array of fixed-size memory pools |
| CVisibility::PortalSystemLoadInfo | |
| CPosixAppLauncher | Launch an external application using fork/execve |
| CPosixBarrier | Implements the 2 macros ReadWriteBarrier and MemoryBarrier |
| CPosix::PosixCpu | CPU related definitions for the Posix platform |
| CPosix::PosixCriticalSection | Posix-implementation of critical section |
| CPosix::PosixEnvironment | Provides read-access to environment variables |
| CPosix::PosixEvent | Posix implmentation of an event synchronization object |
| CPosix::PosixFileTime | Implements a Posix-specific file-access time stamp |
| CPosix::PosixFSWrapper | Internal filesystem wrapper for Posix |
| CPosix::PosixGuid | Posix implementation of the Util::Guid class |
| CPosix::PosixHeap | Posix implementation of the class Memory::Heap using the Posix-Heap functions |
| CPosix::PosixIpAddress | Represents an IP address, consisting of a IPv4 host address and a port number |
| CPosix::PosixMemoryPool | FIXME: IMPLEMENT ME! |
| CPosix::PosixReadWriteLock | |
| CPosix::PosixSettings | A simple wrapper class to store config files in the users home directory Uses Boosts Property_tree library for the time being |
| CPosix::PosixSystemInfo | Provide information about the system we're running on |
| CPosix::PosixThreadBarrier | Block until all thread have arrived at the barrier |
| CPosixThreadId | A thread id uniquely identifies a thread within the process |
| CPosix::PosixTimer | Posix implementation of the Time::Timer class |
| CPQuatFeedbackLoop | A specialized proportional feedback loop for rotations, using a quaternion representation |
| CCoreGraphics::PrimitiveGroup | Defines a group of primitives as a subset of a vertex buffer and index buffer plus the primitive topology (triangle list, etc...) |
| CCoreGraphics::PrimitiveTopology | The primitive topology for a draw call |
| CPriorityArray | A fixed size priority array |
| CUtil::PriorityArray< TYPE > | |
| CJobs::PrivateMemory | |
| CBase::Process | Base class for launching an external application |
| CPosix::PosixProcess | |
| CWin32::Win32Process | |
| CGame::Processor | |
| CGame::ProcessorBuilder | |
| CGame::ProcessorJobContext | |
| CGame::ProcessorJobInput | |
| CProfiling::ProfilingContext | Thread context of profiling |
| CProfiling::ProfilingScope | |
| CProfiling::ProfilingScopeLock | Convenience class used to automatically push and pop scopes |
| CNebula.Game.Property | |
| CNebula.Game.TemplateManager.Template.PropertyData | |
| CNebula.Game.PropertyManager | |
| CPtr< TYPE > | Nebula's smart pointer class which manages the life time of RefCounted objects |
| CSystem::ByteOrder::PunDoubleULL | |
| CSystem::ByteOrder::PunFloatUL | |
| Cphysx::PxAllocatorCallback | |
| CPhysics::Allocator | |
| Cphysx::PxErrorCallback | |
| CPhysics::ErrorCallback | |
| Cphysx::PxSimulationEventCallback | |
| CPhysics::PhysxState | |
| CQuadTree | A simple quad tree |
| CUtil::QuadTree< TYPE > | |
| CVisibility::QuadtreeSystemLoadInfo | |
| CMath::quat | A quaternion is usually used to represent an orientation in 3D space |
| CGame::Orientation | A component that stores the orientation of an entity |
| CAttr::QuaternionTypeClass | |
| CQuatX | |
| CVulkan::GraphicsDeviceState::Queries | |
| CVulkan::QueryBundle | |
| CVulkan::QueryBundle::QueryChunk | |
| CVulkan::QueryBundle::QueryState | |
| CUtil::Queue< TYPE > | Nebula's queue class (a FIFO container) |
| CUtil::Queue< Util::KeyValuePair< PRITYPE, TYPE > > | |
| CThreading::SafePriorityQueue< PRITYPE, TYPE > | A thread-safe priority-sorted queue which protects itself with critical sections |
| CUtil::RandomNumberTable | A table-based random-number generator |
| CUtil::RandomUnion | |
| CMath::randxorstate | Fast random generator based on xorshift+ |
| CMemory::RangeAllocation | Describes a range allocated by the Memory::RangeAllocator |
| CMemory::RangeAllocator | Allocates memory ranges using the TLSF method, with extended handling of padding to better suit GPUs |
| CMemory::RangeAllocator::RangeAllocatorNode | |
| CIm3d::Ray | |
| CCoreGraphics::RayDispatchTable | |
| CCoreGraphics::RayTracingBits | Get shader program raytracing bits |
| CRaytracing::RaytracingSetupSettings | |
| CMath::rectangle< TYPE > | A 2d rectangle class |
| CCore::RefCounted | The common base class of Nebula |
| CAnimation::AnimJob | Descibes a single animation sampling job in the AnimController |
| CAnimation::PlayClipJob | An AnimJob which simply plays an animation clip |
| CAttr::AttributeTable | A table of attributes with a compact memory footprint and fast random access |
| CDb::ValueTable | A table of database values |
| CAudio::AudioDevice | Central class of the core audio subsystem |
| CAudio::AudioServer | Front-end of the Audio subsystem |
| CBase::DisplayDeviceBase | A DisplayDevice object represents the display where the RenderDevice presents the rendered frame |
| CGLFW::GLFWDisplayDevice | |
| CVulkan::VkDisplayDevice | |
| CWin32::Win32DisplayDevice | Win32 implementation of DisplayDevice class |
| CBase::GameContentServerBase | The game content server initializes access to game content on console platforms |
| CBase::InputServerBase | The InputServer is the central object of the Input subsystem |
| CGLFW::GLFWInputServer | |
| CInput::InputServer | The InputServer is the central object of the Input subsystem |
| CBase::InstanceRendererBase | |
| CVulkan::VkInstanceRenderer | |
| CBase::InstanceServerBase | |
| CVulkan::VkInstanceServer | |
| CBase::ShaderServerBase | The ShaderServer loads all shaders when created, meaning all shaders in the project must be valid and hardware compatible when starting |
| CVulkan::VkShaderServer | |
| CBase::ShapeRendererBase | Base class of ShapeRenderer, can render a number of shapes, mainly for debug visualization |
| CVulkan::VkShapeRenderer | |
| CBase::TextRendererBase | Base class for text rendering (don't use this for high-quality text rendering) |
| CVulkan::VkTextRenderer | |
| CBaseGameFeature::LevelParser | Base class for level parsing |
| CCore::CoreServer | The central core server object initializes a minimal Nebula runtime environment necessary to boot up the rest of Nebula |
| CCoreAnimation::AnimKeyBuffer | A simple buffer of vec4 animation keys |
| CCoreGraphics::DisplayEventHandler | A display event handler object is notified by the DisplayDevice about noteworthy window events, for instance when the mouse is moved, the window is minimized, and so on |
| CCoreGraphics::ThreadSafeDisplayEventHandler | A thread-safe subclass of DisplayEventHandler |
| CDynui::ImguiDisplayEventHandler | Handles display events such that ImGui is made aware of them |
| CGraphics::GraphicsDisplayEventHandler | Handles DisplayEvents that are relevant for the graphics system |
| CInput::InputDisplayEventHandler | Translates DisplayEvents that are relevant for the input system into InputEvents |
| CCoreGraphics::RenderEventHandler | A render event handler object is notified by the RenderDevice about noteworthy events |
| CCoreGraphics::ThreadSafeRenderEventHandler | A thread-safe subclass of RenderEventHandler |
| CDb::Command | Wraps a general SQL command |
| CDb::Sqlite3Command | SQLite3 implementation of Db::Command |
| CDb::Database | Wraps an entire database into a C++ object |
| CDb::Sqlite3Database | SQLite3 implementation of Db::Database |
| CDb::Dataset | A dataset is an efficient in-memory-cache for rlational database data |
| CDb::Sqlite3Dataset | SQLite implemention of Dataset |
| CDb::DbFactory | DbFactory object for the Db subsystem |
| CDb::Sqlite3Factory | Creates Db objects derived for the Sqlite3 Db wrapper |
| CDb::DbServer | Provides highlevel access to the world database |
| CDb::FilterSet | Implements a filter for datatbase data using a condition tree |
| CDb::Sqlite3FilterSet | |
| CDb::Reader | Wrapper to bulk-read the contents of a database table |
| CDb::Relation | A Relation object describes a relation between 2 tables which are linked through a common attribute |
| CDb::Table | Describes a table in a database, or more abstract, a set of typed columns grouped under a common name |
| CDb::Sqlite3Table | |
| CDb::Writer | A wrapper class to bulk-write data to the database in a simple way |
| CDebug::DebugCounter | A debug counter for counting events |
| CDebug::DebugServer | The debug server singleton is visible from all threads and keeps track of debug timer and debug counters |
| CDebug::DebugTimer | A debug timer for measuring time spent in code blocks |
| CDynui::ImguiAddon | (C) 2012-2016 Individual contributors, see AUTHORS file |
| CDynui::ImguiConsole | The ImGui console uses ImGui to produce a live interactive console |
| CDynui::ImguiProfiler | |
| CFrame::FrameScript | A FrameScript describes render operations being done to produce a single frame |
| CFrame::FrameServer | |
| CFrameSync::FrameSyncTimer | A thread-local time source object which is synchronized with the sync point in the FrameSyncHandlerThread |
| CGame::FeatureUnit | A FeatureUnit is an encapsulated feature which can be added to an application |
| CAudioFeature::AudioFeatureUnit | Sets up and interfaces with the audio subsystem |
| CBaseGameFeature::BaseGameFeatureUnit | The BaseGameFeatureUnit creates everything to allow load and run a game level |
| CGraphicsFeature::GraphicsFeatureUnit | Sets up the core rendering system and provides properties and managers for default usage, such as rendering models, animations, particles, etc |
| CMultiplayer::MultiplayerFeatureUnit | |
| CNavigationFeature::NavigationFeatureUnit | |
| CPhysicsFeature::PhysicsFeatureUnit | Sets up and interfaces with the physics subsystem |
| CScripting::ScriptFeatureUnit | |
| CGame::GameServer | The game server setups and runs the game world |
| CGame::Manager | Managers are objects which care about some specific functionality of a feature |
| CAudioFeature::AudioManager | |
| CGame::BlueprintManager | Loads the 'data:tables/blueprint.json' file and subsequently sets up categories based on the blueprints in the entity manager |
| CGame::TimeManager | Singleton object which manages all Game::TimeSource objects |
| CGraphicsFeature::CameraManager | Handles camera related properties |
| CGraphicsFeature::GraphicsManager | Handles logic for connecting the game layer with the render layer |
| CNavigationFeature::NavigationManager | |
| CPhysicsFeature::CharacterManager | |
| CPhysicsFeature::PhysicsManager | |
| CGraphics::GraphicsServer | The graphics server is the main singleton for the Graphics subsystem |
| CHttp::HttpClientRegistry | The HttpClientRegistry provides a way to re-use existing connections to HTTP servers instead of setting up a HTTP connection for every single HTTP request |
| CHttp::HttpRequestHandler | HttpRequestHandlers are attached to the HttpServer and process incoming HTTP requests |
| CDebug::ConsolePageHandler | Print console output to HTML page |
| CDebug::CorePageHandler | Provide information about Core subsystem to debug http server |
| CDebug::DebugPageHandler | Http request handler for the Debug subsystem |
| CNavigation::NavigationPageHandler | Provide information about the navigation system |
| CDebug::DisplayPageHandler | Provide information about the display to the debug http server |
| CDebug::HelloWorldRequestHandler | Most simple HttpRequestHandler possible |
| CDebug::IoPageHandler | Provide information about IO subsystem to debug http server |
| CDebug::MemoryPageHandler | Provide information about memory allocations to debug http server |
| CDebug::MeshPageHandler | Provide an HTML debug page with information about shared mesh resources |
| CDebug::ShaderPageHandler | Provide a HTML debug page for shaders |
| CDebug::StringAtomPageHandler | |
| CDebug::SvgTestPageHandler | A HTTP test page handler to test SVG rendering functionality |
| CDebug::TexturePageHandler | Provide a HTML debug page with information about all shared texture resources |
| CDebug::ThreadPageHandler | Displays info about currently running Nebula threads |
| CHttp::DefaultHttpRequestHandler | This implements the "Home Page" of the Nebula application |
| CHttp::HttpServer | Implements an extremly simple standalone HTTP server with attached HttpRequestHandlers |
| CHttp::HttpServerProxy | Client-side proxy of the HttpServer |
| CHttp::NebulaHttpClient | |
| CHttp::HttpClient | Use a HTTP client to send HTTP requests to a HTTP server, and receive and decode HTTP responses |
| CIO::ArchiveBase | Base class of file archives |
| CIO::ZipArchive | Private helper class for ZipFileSystem to hold per-Zip-archive data |
| CIO::ArchiveFileSystemBase | |
| CIO::ZipFileSystem | An archive filesystem wrapper for ZIP files |
| CIO::AssignRegistry | Central registry for path assigns |
| CIO::Console | Nebula's console, this is the central place for command- line-style communication with the user |
| CIO::ConsoleHandler | Base class for all console handlers |
| CDynui::ImguiConsoleHandler | Consolehandler that prints its output to the imgui console |
| CIO::HistoryConsoleHandler | A console handler which stores the last N log messages in a Util::RingBuffer<String> |
| CIO::LogFileConsoleHandler | A console handler which writes all console output to a log file |
| COSX::OSXConsoleHandler | The default console handler for OSX, puts messages to stdout and stderr, reads from stdin |
| CPosix::PosixConsoleHandler | The default console handler for Posix, puts normal messages to the debug output channel, and error messages into a message box |
| CWin32::Win32ConsoleHandler | The default console handler for Win32, puts normal messages to the debug output channel, and error messages into a message box |
| CIO::IoServer | The central server object of the IO subsystem offers the following services: |
| CIO::SchemeRegistry | Central registry for URI schemes, associates an URI scheme (e.g |
| CIO::Stream | Offers an abstract interface for read/write access to a sequence of bytes |
| CIO::CachedStream | Wraps an underlying mappable stream object to avoid reopening it more than once (e |
| CIO::CachedHttpStream | |
| CIO::FileStream | A stream to which offers read/write access to filesystem files |
| CIO::SafeFileStream | Wrapper around FileStream that will save to a temporary file and swap when closed |
| CIO::MemoryStream | Implements a stream class which writes to and reads from system RAM |
| CHttp::HttpNzStream | A version of HttpStream which reads .nz compressed files as created by the Nebula archiver tool |
| CHttp::HttpStream | Wraps client HTTP requests to a HTTP server into an IO::Stream |
| CIO::EmbeddedMemoryStream | Implements a stream class which reads from an embedded resource |
| CIO::ZipFileStream | Wraps a file in a zip archive into a stream |
| CIO::StreamCache | Explicit cache for reusing read-only streams that are already opened |
| CIO::StreamReader | Stream reader classes provide a specialized read-interface for a stream |
| CCoreGraphics::Nvx3StreamReader | |
| CHttp::HttpRequestReader | A stream reader which cracks a HTTP request into its components |
| CHttp::HttpResponseReader | Decodes a response header from a HTTP server and optionally writes received content data to a provided stream |
| CIO::BXmlReader | Stream reader for binary XML files |
| CIO::BinaryReader | A friendly interface to read binary data from a stream |
| CIO::ExcelXmlReader | A stream reader class which reads Excel XML files |
| CIO::JsonReader | Reads json formatted data with random access from a stream using pjson as backend |
| CIO::TextReader | A friendly interface for reading text data from a stream |
| CIO::XmlReader | Reads XML formatted data with random access from a stream using TinyXML as backend |
| CMessaging::MessageReader | Implements a binary stream protocol for decoding messages from a stream |
| CIO::StreamWriter | Stream writer classes provide a specialized write-interface for a stream |
| CHttp::HtmlPageWriter | A stream writer which supports writing a HTML-formatted page into a stream |
| CHttp::HttpRequestWriter | Writes a valid HTTP request header to a stream |
| CHttp::HttpResponseWriter | Stream writer which writes a correct HTTP response to a stream |
| CHttp::SvgPageWriter | A stream writer to generate simple SVG pages |
| CHttp::SvgLineChartWriter | Specialized SVG page writer which draws a line chart diagrams |
| CIO::BinaryWriter | A friendly interface for writing binary data to a stream |
| CIO::JsonWriter | Write Json-formatted data to a stream |
| CIO::TextWriter | A friendly interface for writing text data to a stream |
| CIO::XmlWriter | Write XML-formatted data to a stream |
| CMessaging::MessageWriter | Implements a binary stream protocol for encoding messages into streams |
| CInput::InputHandler | Input handlers receive and process input events |
| CBase::GamePadBase | An input handler which represents one of at most 4 game pads |
| CBase::KeyboardBase | An input handler which represents a keyboard for polling |
| CBase::MouseBase | An input handler which represents a mouse for polling |
| CInput::Mouse | An input handler which represents a mouse for polling |
| CDynui::ImguiInputHandler | This input handler passes input events to Imgui |
| CTBUI::TBUIInputHandler | This input handler passes input events to Turbobadger |
| CLinux::LinuxThread | Linux implementation of Threading::Thread |
| CMemDb::Database | |
| CMessaging::AsyncPort | Runs its handlers in a separate thread, so that message processing happens in a separate thread and doesn't block the main thread |
| CInterface::InterfaceBase | Base class for interfaces |
| CDebug::DebugInterface | Interface object of the Debug subsystem |
| CHttp::HttpInterface | The HttpInterface launches the HttpServer thread and is the communication interface with the HttpServer thread |
| CIO::IoInterface | |
| CMessaging::Handler | Message handlers are used to process a message |
| CAnimation::AnimEventHandlerBase | This is the base class for handling animation events |
| CAnimation::AnimEventServer | This is the server, which is triggered if a animation event is emitted |
| CInterface::InterfaceHandlerBase | Base class for message handlers attached to Interface objects |
| CDebug::DebugHandler | The message handler for the debug interface |
| CHttp::HttpMessageHandler | Runs the HttpServer thread, and owns the central http server |
| CIO::IoInterfaceHandler | Handler class for io interfaces |
| CMessaging::Message | Messages are packets of data which can be sent to a message port |
| CHttp::AttachRequestHandler | |
| CHttp::HttpRequest | Encapsulates a complete Http request into a message |
| CHttp::RemoveRequestHandler | |
| CIO::CopyFile | |
| CIO::IOMessage | |
| CIO::CreateDirectory | |
| CIO::DeleteDirectory | |
| CIO::DeleteFile | |
| CIO::MountArchive | |
| CIO::ReadStream | |
| CIO::WriteStream | |
| CMessaging::BatchMessage | A batch of messages which is itself a message |
| CMessaging::Port | A message port is a receiving point for messages |
| CMessaging::Dispatcher | A message Dispatcher is a specialization of a message Port |
| CNet::StdTcpClient | A TcpClient object is used to communicate with a TcpServer |
| CNet::StdTcpClientConnection | A TcpClientConnection represents a connected TcpClient on the server side |
| CNet::StdTcpServer | A TcpServer opens a socket and listens for connecting TcpClients |
| COSX::OSXThread | OSX implementation of Threading::Thread |
| CPicking::PickingServer | Server responsible to handle id-based rendering |
| CPosix::PosixSocket | A lowlevel socket wrapper class |
| CPosix::PosixThread | Posix implementation of thread class |
| CRenderModules::RTPlugin | Standard interface to add new functionality to the render thread |
| CDynui::ImguiRTPlugin | |
| CRenderModules::RTPluginRegistry | The central registry for render thread plugins |
| CRenderModules::RenderModule | A RenderModule wraps a specific, optional, rendering functionality into a simple object which only requires a simple setup |
| CResources::ResourceLoader | |
| CCharacters::SkeletonLoader | |
| CCoreAnimation::AnimationLoader | |
| CCoreGraphics::GPULangShaderLoader | Resource loader to load a GPULang shader object from a stream |
| CCoreGraphics::MeshLoader | |
| CCoreGraphics::ShaderLoader | |
| CCoreGraphics::TextureLoader | |
| CMaterials::MaterialLoader | |
| CModels::ModelLoader | |
| CNavigation::StreamNavMeshCache | |
| CParticles::ParticleLoader | |
| CPhysics::StreamActorPool | |
| CResources::ResourceSaver | |
| CResources::ResourceServer | |
| CScripting::NSharpServer | C# backend for the Nebula scripting subsystem |
| CScripting::ScriptServer | Server class of the scripting subsystem |
| CScripting::PythonServer | Python backend for the Nebula scripting subsystem |
| CThreading::ObjectRef | A thread-safe reference to a shared object |
| CVisibility::VisibilityContainer | |
| CWin32::Win32Socket | A lowlevel socket wrapper class |
| CWin32::Win32Thread | Win32 implementation of thread class |
| CGame::World::RemoveComponentCommand | |
| CModels::ModelContext::ModelInstance::Renderable | The bounding boxes are used by visibility and the states by rendering |
| CStaticUI::UltralightRenderer::RenderBufferHandle | |
| CCoreGraphics::RenderEvent | Render events are sent by the RenderDevice to registered render event handlers |
| CCoreGraphics::RenderPassCreateInfo | |
| CCoreGraphics::RenderPassId | |
| CVulkan::RenderPassShaderInterface | |
| CCoreGraphics::RenderShape | Describes a shape which is rendered through the ShapeRenderer singleton |
| CCoreGraphics::RenderShape::RenderShapeVertex | |
| CTiXmlString::Rep | |
| CCoreGraphics::ResizeInfo | |
| CResources::Resource | |
| CNebula.Game.ResourceDescriptor | Represents a native descriptor for a resource name |
| CResources::ResourceLoader::ResourceInitOutput | |
| CResources::ResourceLoader::ResourceLoadJob | |
| CResources::ResourceLoader::ResourceLoadOutput | |
| CCoreGraphics::ResourcePipelineCreateInfo | |
| CCoreGraphics::ResourcePipelineId | |
| CCoreGraphics::ResourcePipelinePushConstantRange | |
| CResources::ResourceLoader::ResourceStreamOutput | |
| CCoreGraphics::ResourceTableBuffer | |
| CCoreGraphics::ResourceTableCreateInfo | |
| CCoreGraphics::ResourceTableId | |
| CCoreGraphics::ResourceTableInputAttachment | |
| CCoreGraphics::ResourceTableLayoutAccelerationStructure | |
| CCoreGraphics::ResourceTableLayoutConstantBuffer | |
| CCoreGraphics::ResourceTableLayoutCreateInfo | |
| CCoreGraphics::ResourceTableLayoutId | |
| CCoreGraphics::ResourceTableLayoutInputAttachment | |
| CCoreGraphics::ResourceTableLayoutSampler | |
| CCoreGraphics::ResourceTableLayoutShaderRWBuffer | |
| CCoreGraphics::ResourceTableLayoutTexture | |
| CCoreGraphics::ResourceTableSampler | |
| CCoreGraphics::ResourceTableSet | Set of buffers which creates a resource table per each buffered frame |
| CCoreGraphics::ResourceTableTexture | |
| CCoreGraphics::ResourceTableTextureView | |
| CCoreGraphics::ResourceTableTlas | |
| CResources::ResourceUnknownId | |
| CMemory::RingAlloc | |
| CMemory::RingAllocator< SYNCPOINTS > | Allocates memory up-front, and then allows other systems to grab regions |
| CUtil::RingBuffer< TYPE > | A ring buffer stores up to a maximum number of elements in a circular fashion |
| CRound | Helper class for rounding up integer values to 2^N values |
| CUtil::Round | |
| CMemDb::RowId | Row identifier |
| CCore::Rtti | Nebula's runtime type information for one class |
| CUtil::RunLengthCodec | A simple byte-based runlength encoder/decoder |
| CNebula.Runtime | |
| CNebula.Runtime.RuntimeData | |
| CThreading::SafeFlag | A thread-safe flag variable |
| CThreading::SafeQueue< TYPE > | Thread-safe version of Util::Queue |
| CCoreGraphics::SamplerCreateInfo | |
| CCoreGraphics::SamplerId | |
| CCoreAnimation::SampleType | Describes how an animation curve should be sampled |
| CIm3d::internal::ScalarT | |
| CIm3d::internal::FloatT | |
| CIm3d::internal::IntT | |
| CPhysics::Scene | Physx scene classes, foundation and physics are duplicated here for convenience instead of static getters, might be removed later on |
| CVulkan::SceneSetup | |
| CVulkan::ScissorBundle | |
| CCoreGraphics::SemaphoreCreateInfo | |
| CCoreGraphics::SemaphoreId | |
| CGame::ComponentSerialization::Serializer | |
| CMultiplayer::ServerProcessorContext | |
| CUtil::Set< KEYTYPE > | A collection of unique values with quick lookup |
| CCoreGraphics::GpuBufferTypes::SetupFlags | |
| CMaterials::ShaderConfigBatchTexture | |
| CCoreGraphics::ShaderFeature | Wrapper class for shader permutations by name |
| CCoreGraphics::ShaderId | |
| CCoreGraphics::ShaderIdentifier | The ShaderIdentifier is a zero-indexed registry which is used to identify shaders in a constant time (instead of using dictionaries) which can be used to select variables and whatnot using a FixedArray, which is guaranteed to retain the same index during the execution of the application |
| CShaderServer | The ShaderServer object loads the available shaders and can instantiate shaders for usage |
| CLighting::LightContext::ShadowData | |
| CPhysics::ShapeHandle | |
| CShapeRenderer | Render shapes for debug visualizations |
| CAttr::ShortTypeClass | |
| CUtil::SimpleTree< VALUETYPE > | A simple tree class which stores its nodes in Util::Arrays |
| CSingleton | Implements a system specific Singleton |
| CCharacters::SkeletonCreateInfo | |
| CCharacters::SkeletonId | |
| CCharacters::SkeletonJobJoint | |
| CCharacters::SkeletonResourceId | |
| CSocket | Platform independent wrapper class for the Sockets API |
| CVulkan::VkSubContextHandler::SparseBindSubmission | |
| CVulkan::GraphicsDeviceState::SparseBufferBind | |
| CCoreGraphics::SparseBufferCreateInfo | |
| CCoreGraphics::SparseBufferId | Sparse buffer type |
| CVulkan::GraphicsDeviceState::SparseImageBind | |
| CUtil::SparseTable< TYPE > | A 2D sparse table where many entries may be redundant and support for multiple entries per cell |
| CIm3d::Sphere | |
| CMath::sphere | A 3-dimensional sphere |
| CThreading::Spinlock | |
| CThreading::SpinlockScope | |
| CLighting::LightContext::SpotLightSetupInfo | |
| CSqlite3FilterSet | SQLite3 implement of Db2::FilterSet |
| CUtil::Stack< TYPE > | Nebula's stack class (a FILO container) |
| CStackTrace | Helper class for generating stack traces |
| CStackWalker | |
| CStackWalkerToString | |
| CGame::GameServer::State | Internal state and world management |
| CMessaging::StaticMessageHandler | Implements a simple, static message handler helper class |
| CUtil::StringAtomTableBase::StaticString | Static string class for sorting the array |
| CStreamAnimationLoader | Initialize a CoreAnimation::AnimResource from the content of a stream |
| CCoreGraphics::MeshLoader::StreamMeshLoadMetaData | |
| CStreamShaderLoader | Resource loader to setup a Shader object from a stream |
| CStreamTextureCache | Resource loader for loading texture data from a Nebula stream |
| CUtil.String | Nebula's universal string class |
| CAttr::StringArrayTypeClass | |
| CUtil::StringAtom | A StringAtom |
| CUtil::StringAtomTableBase | This implements the base class for thread-local and global string atom table classes |
| CUtil::GlobalStringAtomTable | Global string atom table |
| CUtil::LocalStringAtomTable | Implements a thread-local string atom table which is used as a cache to prevent excessive locking when creating string atoms |
| CUtil::StringBuffer | Global string buffer for the StringAtom system |
| CTiXmlBase::StringToBuffer | |
| CAttr::StringTypeClass | |
| CVulkan::VkSubContextHandler::SubmissionList | |
| CCoreGraphics::SubmissionWaitEvent | |
| CCoreGraphics::Subpass | |
| CCoreGraphics::SubpassInfo | |
| CTerrain::SubTexture | |
| CTerrain::SubTextureCompressed | |
| CTerrain::SubTextureUpdateJobOutput | |
| CTerrain::SubTextureUpdateJobUniforms | |
| CCoreGraphics::SwapchainCreateInfo | |
| CCoreGraphics::SwapchainId | |
| CCoreGraphics::DrawThread::SyncCommand | |
| CSysFunc | Wrap some platform specific low-level functions |
| COSX::SysFunc | Lowest-level functions for OSX platform |
| CPosix::SysFunc | Provides Posix specific helper functions |
| CWin32::SysFunc | Provides Win32 specific helper functions |
| CSystemInfo | Provides information about the host system |
| CBase::SystemInfoBase | |
| CDarwin::DarwinSystemInfo | Provide information about the system we're running on |
| CMemDb::Table | A table of columns (attributes) and rows |
| CMemDb::TableCreateInfo | Information for creating a table |
| CUtil::SparseTable< TYPE >::TableEntry | Table entry in the sparse table |
| CMemDb::TableId | Table identifier |
| CMemDb::TableSignature | Basically a bitfield with packed ComponentIds |
| Ctb::TBBitmap | |
| CTBUI::TBUIBitmap | |
| Ctb::TBClipboardInterface | |
| CTBUI::TBUIClipboardInterface | |
| Ctb::TBFile | |
| CTBUI::TBUIFile | |
| Ctb::TBFileInterface | |
| CTBUI::TBUIFileInterface | |
| Ctb::TBFontRenderer | |
| CTBUI::TBUISTBFontRenderer | STBFontRenderer renders fonts using stb_truetype.h (http://nothings.org/) |
| Ctb::TBRendererBatcher | |
| CTBUI::TBUIRenderer | |
| Ctb::TBSystemInterface | |
| CTBUI::TBUISystemInterface | |
| CTBUI::TBUIBatch | |
| CTBUI::TBUIContext::TBUIState | |
| CTBUI::TBUIVertex | |
| Ctb::TBWidget | |
| CTBUI::TBUIView | |
| CTcpClient | See StdTcpClient for details |
| CNet::MessageClient | Wrapper class for the Net::TcpClient that sends data in special message container |
| CTcpClientConnection | See StdTcpClientConnection for details! |
| CNet::MessageClientConnection | A wrapper class for the Net::TcpClientConnection |
| CNet::TcpMessageCodec | Helperclass that provides function to encode and decode sreams into messages |
| CTcpServer | Front-end wrapper class for StdTcpServer, see StdTcpServer for details! |
| CNebula.Game.TemplateManager.Template | |
| CGame::TemplateId | |
| CNebula.Game.TemplateManager | |
| CTerrain::TerrainBiomeId | |
| CTerrain::TerrainCreateInfo | |
| CTerrain::TerrainContext::TerrainInstanceInfo | |
| CTerrain::TerrainContext::TerrainLoadInfo | |
| CTerrain::TerrainQuad | |
| CTerrain::TerrainContext::TerrainRuntimeInfo | |
| CTerrain::TerrainSetupSettings | |
| CTerrain::TerrainTri | |
| CTerrain::TerrainVert | |
| CIm3d::TextData | |
| CIm3d::TextDrawList | |
| CCoreGraphics::TextElement | Describes a text element for the text renderer |
| CVulkan::VkTextRenderer::TextElementVertex | |
| CTextRenderer | A simple text renderer for drawing text on screen |
| CCoreGraphics::TextureBarrier | |
| CCoreGraphics::TextureBarrierInfo | |
| CCoreGraphics::TextureCopy | Struct for texture copies |
| CCoreGraphics::TextureCreateInfo | |
| CCoreGraphics::TextureCreateInfoAdjusted | |
| CVulkan::VkTextureLoadInfo | |
| CFrame::FrameOp::TextureDependency | |
| CCoreGraphics::TextureDimensions | |
| CFrame::TextureExport | |
| CStaticUI::UltralightRenderer::TextureHandle | |
| CCoreGraphics::TextureId | Texture type |
| CFrame::TextureImport | |
| CCoreGraphics::TextureRelativeDimensions | |
| CCoreGraphics::TextureSparsePage | |
| CCoreGraphics::TextureSparsePageOffset | |
| CCoreGraphics::TextureSparsePageSize | |
| CVulkan::TextureSparsePageTable | |
| CCoreGraphics::TextureStreamData | |
| CFrame::FrameOp::TextureSubresourceDep | |
| CCoreGraphics::TextureSubresourceInfo | |
| CCoreGraphics::TextureSwizzle | |
| CTerrain::TextureTileCache | |
| CCoreGraphics::TextureViewCreateInfo | |
| CCoreGraphics::TextureViewId | |
| CTextWriter | |
| CConsoleHook.ConsoleWriter | |
| CThread | |
| CCoreGraphics::DrawThread | A CoreGraphics thread meant to only record draw commands to command buffers |
| CVulkan::VkCommandBufferThread | |
| CFibers::FiberThread | |
| CIO::FileWatcher | For registering callbacks for file modification events |
| CJobs2::JobThread | |
| CJobs::JobThread | |
| CMessaging::HandlerThreadBase | Base class for AsyncPort message handler thread classes |
| CMessaging::BlockingHandlerThread | Message handler thread class which blocks until messages arrive (or optionally, a time-out occurs) |
| CMessaging::RunThroughHandlerThread | A simple handler thread class which "runs thru", and doesn't wait for messages |
| CNet::StdTcpServer::ListenerThread | Private listener thread class |
| CResources::ResourceLoaderThread | |
| CThreadBarrier | Block until all thread have arrived at the barrier |
| CThreadLocalMiniHeap | |
| CTerrain::TileCacheEntry | |
| CPhysics::VisualDebugger::TimedDrawData | Base class for draw-calls that should be done over a number of steps |
| CVulkan::VkSubContextHandler::TimelineSubmission | |
| CVulkan::VkSubContextHandler::TimelineSubmission2 | |
| CTimer | A timer object is the most basic object for time measurement |
| CGame::TimeSource | An object that keeps track of running time and frame time (delta time) |
| CGame::TimeSourceCreateInfo | Used to create a timesource |
| CIO::XmlReader::TinyXmlInitHelper | Static helper object for TinyXml-Initialization at application startup |
| CTiXmlAttributeSet | |
| CTiXmlBase | TiXmlBase is a base class for every class in TinyXml |
| CTiXmlAttribute | An attribute is a name-value pair |
| CTiXmlNode | The parent class for everything in the Document Object Model |
| CTiXmlComment | An XML comment |
| CTiXmlDeclaration | In correct XML the declaration is the first entry in the file |
| CTiXmlDocument | Always the top level node |
| CTiXmlElement | The element is a container class |
| CTiXmlText | XML text |
| CTiXmlUnknown | Any tag that tinyXml doesn't recognize is saved as an unknown |
| CTiXmlCursor | |
| CTiXmlHandle | A TiXmlHandle is a class that wraps a node pointer with null checks; this is an incredibly useful thing |
| CTiXmlParsingData | |
| CTiXmlString | |
| CTiXmlOutStream | |
| CCoreGraphics::TlasCreateInfo | |
| CCoreGraphics::TlasId | |
| CDb::FilterSet::Token | |
| CMemory::TotalMemoryStatus | Get the system's total current memory, this does not only include Nebula's memory allocations but the memory usage of the entire system |
| CHttp::SvgLineChartWriter::Track | |
| CGame::AngularVelocity::Traits | |
| CGame::Entity::Traits | |
| CGame::Orientation::Traits | |
| CGame::Position::Traits | |
| CGame::Scale::Traits | |
| CGame::Velocity::Traits | |
| CMath::transform | Simple transform using position, quaternion, and scale |
| CMath::transform44 | A 4x4 matrix which is described by translation, rotation and scale |
| CAttr::Transform44TypeClass | |
| CModels::ModelContext::ModelInstance::Transformable | Transforms are only used by the model context to traverse and propagate the transform hierarchy |
| Cnanobind::detail::type_caster< Util::String > | |
| CIm3d::internal::TypeTraits< T > | |
| CIm3d::internal::TypeTraits< float > | |
| CIm3d::internal::TypeTraits< int > | |
| CIm3d::internal::TypeTraits< Mat4 > | |
| CIm3d::internal::TypeTraits< Vec2 > | |
| CIm3d::internal::TypeTraits< Vec3 > | |
| CIm3d::internal::TypeTraits< Vec4 > | |
| CMath::uint2 | |
| CMath::uint3 | |
| CMath::uint4 | |
| CAttr::UIntTypeClass | |
| CVulkan::VkReflectionInfo::UniformBuffer | |
| CVulkan::VkShapeRenderer::UnindexedDraws | |
| CIO::URI | An URI object can split a Uniform Resource Identifier string into its components or build a string from URI components |
| CIO::URN | A URN (Uniform Resource Name) is a URI (Uniform Resource Identifier) that uses the "urn" scheme |
| CAttr::UShortTypeClass | |
| CVulkan::VkReflectionInfo::Variable | |
| CUtil::Variant | An "any type" variable |
| CIm3d::Vec2 | |
| CMath::vec2 | A 2-component float vector class |
| CIm3d::Vec3 | |
| CMath::vec3 | A 3D vector |
| CGame::AngularVelocity | |
| CGame::Position | A component that stores the position of an entity in world space coordinates |
| CGame::Scale | A component that stores the scale of an entity |
| CGame::Velocity | A component that stores the linear velocity of an entity |
| CIm3d::Vec4 | |
| CMath::vec4 | A 4D vector |
| CUtil::Color | Represents colors by four single point (32-bit) floating point numbers |
| CIm3d::Vector< T > | |
| CMath::vector | A vector is a 3D direction in space |
| CVegetation::VegetationBiomeId | |
| CVegetation::VegetationGrassSetup | |
| CVegetation::VegetationMeshSetup | |
| CVegetation::VegetationSetupSettings | |
| CCoreGraphics::VertexAlloc | |
| CCoreGraphics::VertexComponent | Describes a single vertex component in a vertex layout description |
| CBase::VertexComponentBase | |
| CIm3d::VertexData | |
| CVertexLayoutBase | Base class for platform-specific vertex component subclasses |
| CCoreGraphics::VertexLayoutCreateInfo | |
| CCoreGraphics::VertexLayoutId | |
| CCoreGraphics::VertexLayoutInfo | |
| CVulkan::VertexLayoutVkBindInfo | |
| CCoreGraphics::VertexStream | |
| CGame::Dataset::View | This represents a "view" into an entity table |
| CView | A view describes a camera which can observe a Stage |
| CMemDb::Dataset::View | A view into a category table |
| CGraphics::ViewCreateInfo | |
| CGraphicsFeature::CameraManager::ViewData | |
| CPostEffects::ViewData | |
| CGraphics::ViewId | |
| CVulkan::ViewportBundle | |
| CVisibility::ObserverContext::VisibilityBatchCommand | |
| CVisibility::ObserverContext::VisibilityDrawCommand | |
| CVisibility::ObserverContext::VisibilityDrawList | |
| CVisibility::ObserverContext::VisibilityModelCommand | |
| CVisibility::VisibilitySystem | |
| CVisibility::BoxSystem | |
| CVisibility::BruteforceSystem | |
| CVisibility::OctreeSystem | |
| CVisibility::PortalSystem | |
| CVisibility::QuadtreeSystem | |
| CPhysics::VisualDebugger | Class that communicates with the physics visual debugger program |
| CVulkan::VkCommandBufferThread::VkBarrierCommand | |
| CVulkan::VkBarrierInfo | |
| CVulkan::VkCommandBufferThread::VkBeginMarkerCommand | |
| CVulkan::VkCommandBufferThread::VkBeginQueryCommand | |
| CVulkan::VkTypes::VkBlockDimensions | |
| CVulkan::VkBufferLoadInfo | |
| CVulkan::VkBufferMapInfo | |
| CVulkan::VkBufferRuntimeInfo | |
| CVulkan::VkCommandBufferThread::VkCommandBufferBeginCommand | |
| CVulkan::VkCommandBufferThread::VkCommandBufferEndCommand | |
| CVulkan::VkCommandBufferThread::VkCommandBufferResetCommand | |
| CVulkan::VkCommandBufferThread::VkComputePipelineBindCommand | |
| CVulkan::VkDeferredCommand | |
| CVulkan::VkCommandBufferThread::VkDescriptorsCommand | |
| CVulkan::VkCommandBufferThread::VkDispatchCommand | |
| CVulkan::VkCommandBufferThread::VkDrawCommand | |
| CVulkan::VkCommandBufferThread::VkEndMarkerCommand | |
| CVulkan::VkCommandBufferThread::VkEndQueryCommand | |
| CVulkan::VkEventInfo | |
| CVulkan::VkFenceInfo | |
| CVulkan::VkCommandBufferThread::VkGfxPipelineBindCommand | |
| CVulkan::VkCommandBufferThread::VkIndexBufferCommand | |
| CVulkan::VkCommandBufferThread::VkIndirectDrawCommand | |
| CVulkan::VkCommandBufferThread::VkIndirectIndexedDrawCommand | |
| CVulkan::VkCommandBufferThread::VkInsertMarkerCommand | |
| CVulkan::VkPassLoadInfo | |
| CVulkan::VkPassRuntimeInfo | |
| CVulkan::VkPipelineBundle | |
| CVulkan::VkPipelineDatabase | |
| CVulkan::VkProgramReflectionInfo | |
| CVulkan::VkCommandBufferThread::VkPushConstantsCommand | |
| CVulkan::VkReflectionInfo | |
| CVulkan::VkCommandBufferThread::VkResetEventCommand | |
| CVulkan::VkScheduler | |
| CVulkan::VkCommandBufferThread::VkScissorRectArrayCommand | |
| CVulkan::VkCommandBufferThread::VkScissorRectCommand | |
| CVulkan::VkCommandBufferThread::VkSetEventCommand | |
| CVulkan::VkShaderProgramRuntimeInfo | |
| CVulkan::VkShaderProgramSetupInfo | |
| CVulkan::VkShaderRuntimeInfo | |
| CVulkan::VkShaderSetupInfo | |
| CVulkan::VkCommandBufferThread::VkStencilReadMaskCommand | |
| CVulkan::VkCommandBufferThread::VkStencilRefCommand | |
| CVulkan::VkCommandBufferThread::VkStencilWriteMaskCommand | |
| CVulkan::VkSubContextHandler | |
| CVulkan::VkTextureMappingInfo | |
| CVulkan::VkTextureRuntimeInfo | |
| CVulkan::VkTextureSwapInfo | |
| CVulkan::VkTextureViewLoadInfo | |
| CVulkan::VkTextureViewRuntimeInfo | |
| CVulkan::VkTypes | |
| CVulkan::VkCommandBufferThread::VkUpdateBufferCommand | |
| CVulkan::VkCommandBufferThread::VkVertexBufferCommand | |
| CVulkan::VkCommandBufferThread::VkViewportArrayCommand | |
| CVulkan::VkCommandBufferThread::VkViewportCommand | |
| CVulkan::VkCommandBufferThread::VkWaitForEventCommand | |
| CVulkan::VkCommandBufferThread::VkWriteTimestampCommand | |
| CAttr::VoidPtrTypeClass | |
| CGI::DDGIContext::Volume | |
| CGI::DDGIContext::VolumeSetup | |
| CIO::WatchEvent | |
| CWeakPtr< TYPE > | A smart pointer which does not change the reference count of the target object |
| CWin32Barrier | Implements the 2 macros ReadWriteBarrier and MemoryBarrier |
| CWin32::Win32Cpu | CPU related definitions for the Win32 platform |
| CWin32::Win32CriticalSection | Win32-implementation of critical section |
| CWin32::Win32Environment | Provides read-access to environment variables |
| CWin32::Win32Event | Win32 implementation of an event synchronization object |
| CWin32::Win32FileTime | Implements a Win32-specific file-access time stamp |
| CWin32::Win32FSWrapper | Internal filesystem wrapper for Win32 |
| CWin32::Win32Guid | Win32 implementation of the Util::Guid class |
| CWin32::Win32Heap | Win32 implementation of the class Memory::Heap |
| CWin32Interlocked | Provides simple atomic operations on shared variables |
| CWin32::Win32IpAddress | Represents an IP address, consisting of a IPv4 host address and a port number |
| CWin32::Win32MemoryPool | A simple thread-safe memory pool |
| CWin32::Win32MiniDump | Win32 implementation of MiniDump |
| CWin32Process | Launch an external Win32 application |
| CWin32::Win32ReadWriteLock | |
| CWin32::Win32Registry | A simple wrapper class to access the Win32 registry |
| CWin32::Win32StackTrace | |
| CWin32Stacktrace | Win32 implementation of stacktrace |
| CWin32::Win32StringConverter | Convert between UTF-8 and 16-bit wide strings |
| CWin32::Win32SystemInfo | Provide information about the system we're running on |
| CWin32::Win32ThreadBarrier | Block until all thread have arrived at the barrier |
| CWin32::Win32Timer | Win32 implementation of the Time::Timer class |
| CCoreGraphics::WindowCreateInfo | |
| CCoreGraphics::WindowId | |
| CWinThreadId | A thread id uniquely identifies a thread within the process |
| CGame::World | A container of entities, their components, and processors |
| CNebula.Game.World | |
| CGame::WorldHash | |
| CVulkan::WriteInfo | |
| CIO::ZipDirEntry | A directory entry in a zip arcive |
| CIO::ZipFileEntry | A file entry in a zip archive |