| NAnimation | |
| CAnimEventHandlerBase | This is the base class for handling animation events |
| CAnimEventInfo | The AnimEventInfo has extra information of the animevent, like the animjob from which it is initiated |
| CAnimEventServer | This is the server, which is triggered if a animation event is emitted |
| CAnimJob | Descibes a single animation sampling job in the AnimController |
| CAnimJobEnqueueMode | Describes the behaviour when enqueueing a new animation job into an anim sequencer |
| CAnimSequencer | An AnimSequencer object arranges AnimJobs along the time line to produce a single, priority-blended result |
| CPlayClipJob | An AnimJob which simply plays an animation clip |
| NApp | |
| CApplication | Provides a simple application model for Nebula apps |
| CConsoleApplication | Base class for Nebula console applications |
| CGameApplication | Nebula's default game application |
| CGameAppExitHandler | |
| CRenderApplication | Render application class with multithreaded rendering |
| CViewerApplication | Derived from RenderApplication, adds support for Stages, Views and GraphicsEntities to the asynchronous render app |
| NAttr | |
| CAttrExitHandler | Exit handler for the Attr subsystem, cleans up dynamic attribute definitions before shutdown |
| CAttribute | A compiletime-typesafe key/value pair |
| CAttributeContainer | A simple container for attributes |
| CAttributeDefinition | This extends the typeless AttributeDefinitionBase class by a typed template class, which adds compiletime-type-safety to attribute definitions |
| CAttributeDefinitionBase | Implements a universal attribute definition, consisting of an attribute name, attribute fourcc code, value type and access type |
| CAttributeTable | A table of attributes with a compact memory footprint and fast random access |
| CColumnInfo | |
| CAttrId | An attribute ID is used to carry attribute types (no values) around |
| CBlobArrayTypeClass | |
| CBlobAttrId | Typed attribute id for blob type |
| CBlobTypeClass | |
| CBoolArrayTypeClass | |
| CBoolAttrId | Typed attribute id for bool type |
| CBoolTypeClass | |
| CByteTypeClass | |
| CDoubleTypeClass | |
| CFloat2ArrayTypeClass | |
| CFloat2TypeClass | |
| CFloat4ArrayTypeClass | |
| CFloat4TypeClass | |
| CFloatArrayTypeClass | |
| CFloatAttrId | Typed attribute id for float type |
| CFloatTypeClass | |
| CGuidArrayTypeClass | |
| CGuidAttrId | Typed attribute id for guid type |
| CGuidTypeClass | |
| CInt64AttrId | |
| CInt64TypeClass | |
| CIntArrayTypeClass | |
| CIntAttrId | Typed attribute id for integer type |
| CIntTypeClass | |
| CMat4AttrId | Typed attribute id for mat4 type |
| CMatrix44ArrayTypeClass | |
| CMatrix44TypeClass | |
| CQuaternionTypeClass | |
| CShortTypeClass | |
| CStringArrayTypeClass | |
| CStringAttrId | Typed attribute id for string type |
| CStringTypeClass | |
| CTransform44TypeClass | |
| CUIntAttrId | Typed attribute id for unsigned integer type |
| CUIntTypeClass | |
| CUShortTypeClass | |
| CVec4AttrId | Typed attribute id for vec4 type |
| CVoidPtrTypeClass | |
| NAudio | |
| CAudioDevice | Central class of the core audio subsystem |
| CListener | |
| CAudioEmitterId | |
| CAudioServer | Front-end of the Audio subsystem |
| CClipId | |
| CClipInstanceId | |
| NAudioFeature | |
| CAudioFeatureUnit | Sets up and interfaces with the audio subsystem |
| CAudioManager | |
| NBase | |
| CCalendarTimeBase | 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 |
| CDisplayDeviceBase | A DisplayDevice object represents the display where the RenderDevice presents the rendered frame |
| CGameContentServerBase | The game content server initializes access to game content on console platforms |
| CGamePadBase | An input handler which represents one of at most 4 game pads |
| CButtonState | |
| CGenericMemoryPool | A simple thread-safe memory pool |
| CInputServerBase | The InputServer is the central object of the Input subsystem |
| CInstanceRendererBase | |
| CInstanceServerBase | |
| CKeyboardBase | An input handler which represents a keyboard for polling |
| CKeyState | |
| CLibrary | Base class for loading and handling dynamic libraries |
| CMouseBase | An input handler which represents a mouse for polling |
| CButtonState | |
| CShaderServerBase | The ShaderServer loads all shaders when created, meaning all shaders in the project must be valid and hardware compatible when starting |
| CShapeRendererBase | Base class of ShapeRenderer, can render a number of shapes, mainly for debug visualization |
| CTextRendererBase | Base class for text rendering (don't use this for high-quality text rendering) |
| CVertexComponentBase | |
| NBaseGameFeature | |
| CBaseGameFeatureUnit | The BaseGameFeatureUnit creates everything to allow load and run a game level |
| CLevelParser | Base class for level parsing |
| NCharacters | A character encapsulates a skeleton resource, an animation resource, and the ability to instantiate such and drive animations |
| CCharacterContext | Assumes control over the character animation functionalities of a model if it contains a character definition and an animation set |
| CAnimationRuntime | |
| CAnimationTracks | |
| CCharacterJobContext | |
| CCharacterJoint | |
| CNsk3Header | NSK3 file format structs |
| CNsk3Joint | |
| CNsk3Skeleton | |
| CSkeletonCreateInfo | |
| CSkeletonId | |
| CSkeletonJobJoint | |
| CSkeletonLoader | |
| CSkeletonResourceId | |
| NClustering | Context handling GPU cluster culling |
| C[struct].state | |
| CClusterContext | |
| NConsoleHook | |
| CConsoleEvents | |
| CConsoleWriterEventArgs | |
| CConsoleWriter | |
| NCore | |
| CCoreServer | The central core server object initializes a minimal Nebula runtime environment necessary to boot up the rest of Nebula |
| CCVar | A console variable |
| CCVarCreateInfo | Used to create a Core::CVar |
| CCVarValue | |
| C[union].__unnamed0__ | |
| CExitHandler | 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 |
| CFactory | Provides the central object factory mechanism for Nebula |
| CRefCounted | The common base class of Nebula |
| CRefCountedList | Implements a static list which keeps track of all refcounted objects to detect refcounting leaks at application shutdown |
| CRtti | Nebula's runtime type information for one class |
| NCoreAnimation | An animation resource holds a set of animations from a loaded NAX file |
| CAnimationCreateInfo | |
| CAnimationId | |
| CAnimationLoader | |
| CAnimationResourceId | |
| CAnimClip | An animation clip is a collection of related animation curves (for instance all curves required to animate a character) |
| CAnimCurve | An animation curve describes a set of animation keys in an AnimKeyBuffer |
| CAnimEvent | An animation event associates a name with a point in time |
| CAnimEventEmitter | The AnimEventEmitter collects all animevents which are active in the given time range |
| CAnimKeyBuffer | A simple buffer of vec4 animation keys |
| CInterval | |
| CAnimSampleBuffer | 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) |
| CAnimSampleMask | |
| CAnimSampleMixInfo | A data structure for providing sample/mixing attributes to asynchronous jobs in the CoreAnimation subsystem |
| CAnimUtil | A class which contains utility methods for animation sampling and mixing |
| CCurveType | Describes the general data type of the keys stored in an animation curve |
| CInfinityType | Describes how time position outsides of an animation curve's scope are handled |
| CNax2Curve | |
| CNax2Group | |
| CNax2Header | Legacy NAX2 file format structs |
| CNax3Anim | |
| CNax3AnimEvent | |
| CNax3Clip | |
| CNax3Curve | |
| CNax3Header | NAX3 file format structs |
| CNax3Interval | |
| CSampleType | Describes how an animation curve should be sampled |
| NCoreGraphics | Acceleration structures are used to enable ray tracing on the GPU by dividing the scene into a BVH |
| NGpuBufferTypes | |
| CSetupFlags | |
| C__Mesh | |
| CAccelerationStructureBarrierInfo | |
| CAdapter | Display adapter enum |
| CAdapterInfo | Contains information about a given display adapter |
| CAlloc | |
| CAllocRange | |
| CAntiAliasQuality | Anti-alias quality levels |
| CBarrierContext | |
| CBarrierCreateInfo | |
| CBarrierId | |
| CBarrierScope | |
| CBarrierStackEntry | |
| CBaseVertex | |
| CBlasCreateInfo | |
| CBlasId | |
| CBlasInstanceCreateInfo | |
| CBlasInstanceId | |
| CBlasInstanceInfo | |
| CBufferBarrier | |
| CBufferBarrierInfo | |
| CBufferCopy | |
| CBufferCreateInfo | |
| CBufferId | |
| CBufferSet | Set of buffers which creates a buffer per each buffered frame |
| CBufferSparsePage | |
| CBufferSubresourceInfo | |
| CBufferWithStaging | |
| CCmdBufferBeginInfo | |
| CCmdBufferClearInfo | |
| CCmdBufferCreateInfo | |
| CCmdBufferId | |
| CCmdBufferMarkerBundle | |
| CCmdBufferPoolCreateInfo | |
| CCmdBufferPoolId | |
| CColorVertex | |
| CDepthStencilClear | |
| CDerivativeStateId | |
| CDisplayEvent | Display events are sent by the display device to registered display event handlers |
| CDisplayEventHandler | 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 |
| CDisplayMode | Describe a fullscreen display mode or window dimensions |
| CDrawThread | A CoreGraphics thread meant to only record draw commands to command buffers |
| CCommand | |
| CSyncCommand | |
| CCommandBuffer | |
| CDrawThreadResult | |
| CEventCreateInfo | |
| CEventId | |
| CFenceCreateInfo | |
| CFenceId | |
| CGliml | |
| CGPULangShaderCreateInfo | |
| CGPULangShaderLoader | Resource loader to load a GPULang shader object from a stream |
| CGraphicsDeviceCreateInfo | |
| CFeatures | |
| CGraphicsDeviceState | |
| CGraphicsDeviceThreadState | |
| CImageCreateInfoData | |
| CImageCreateInfoFile | |
| CImageDimensions | |
| CImageFileFormat | Image file formats supported by StreamTextureSaver |
| CImageId | |
| CImageLoadInfo | |
| CImageData | |
| CIndexType | Data type of vertex indices (16 bit or 32 bit) |
| CInputAssemblyKey | |
| C[struct].__unnamed0__ | |
| CMemoryHeap | |
| CMemoryPool | |
| CMeshCreateInfo | |
| CMeshId | |
| CMeshLoader | |
| CStreamMeshLoadMetaData | |
| CMeshStreamData | |
| CMeshesToSubmit | |
| CFinishedMesh | |
| CMeshResource | |
| CMeshResourceId | |
| CMonitor | |
| CNormalVertex | |
| CNvx2Group | |
| CNvx2Header | NVX2 file format structs |
| CNvx3BBox | |
| CNvx3Elements | |
| CNvx3Group | |
| CNvx3Header | NVX3 file format structs |
| CNvx3Meshlet | |
| CNvx3StreamReader | |
| CNvx3VertexRange | |
| CPassCreateInfo | |
| CPassId | |
| CPinnedBuffer | |
| CPipelineCreateInfo | |
| CPipelineId | |
| CPipelineRayTracingTable | |
| CPixelFormat | Pixel format enumeration |
| CPrimitiveGroup | Defines a group of primitives as a subset of a vertex buffer and index buffer plus the primitive topology (triangle list, etc...) |
| CPrimitiveTopology | The primitive topology for a draw call |
| CRayDispatchTable | |
| CEntry | |
| CRayTracingBits | Get shader program raytracing bits |
| C[struct].bitField | |
| CRenderEvent | Render events are sent by the RenderDevice to registered render event handlers |
| CRenderEventHandler | A render event handler object is notified by the RenderDevice about noteworthy events |
| CRenderPassCreateInfo | |
| CRenderPassId | |
| CRenderShape | Describes a shape which is rendered through the ShapeRenderer singleton |
| CRenderShapeVertex | |
| CResizeInfo | |
| CResourcePipelineCreateInfo | |
| CResourcePipelineId | |
| CResourcePipelinePushConstantRange | |
| CResourceTableBuffer | |
| CResourceTableCreateInfo | |
| CResourceTableId | |
| CResourceTableInputAttachment | |
| CResourceTableLayoutAccelerationStructure | |
| CResourceTableLayoutConstantBuffer | |
| CResourceTableLayoutCreateInfo | |
| CResourceTableLayoutId | |
| CResourceTableLayoutInputAttachment | |
| CResourceTableLayoutSampler | |
| CResourceTableLayoutShaderRWBuffer | |
| CResourceTableLayoutTexture | |
| CResourceTableSampler | |
| CResourceTableSet | Set of buffers which creates a resource table per each buffered frame |
| CResourceTableTexture | |
| CResourceTableTextureView | |
| CResourceTableTlas | |
| CSamplerCreateInfo | |
| CSamplerId | |
| CSecondUVVertex | |
| CSemaphoreCreateInfo | |
| CSemaphoreId | |
| CShaderFeature | Wrapper class for shader permutations by name |
| CShaderId | |
| CShaderIdentifier | 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 |
| CShaderLoader | |
| CSkinVertex | |
| CSparseBufferCreateInfo | |
| CSparseBufferId | Sparse buffer type |
| CSubmissionWaitEvent | |
| CSubpass | |
| CSubpassInfo | |
| CSwapchainCreateInfo | |
| CSwapchainId | |
| CTextElement | Describes a text element for the text renderer |
| CTextureBarrier | |
| CTextureBarrierInfo | |
| CTextureCopy | Struct for texture copies |
| CTextureCreateInfo | |
| C[union].__unnamed0__ | |
| CTextureCreateInfoAdjusted | |
| CTextureDimensions | |
| CTextureId | Texture type |
| CTextureLoader | |
| CMipLoadMainThread | |
| CMipHandoverLoaderThread | |
| CTextureRelativeDimensions | |
| CTextureSparsePage | |
| CTextureSparsePageOffset | |
| CTextureSparsePageSize | |
| CTextureStreamData | |
| CTextureSubresourceInfo | |
| CTextureSwizzle | |
| CTextureViewCreateInfo | |
| CTextureViewId | |
| CThreadSafeDisplayEventHandler | A thread-safe subclass of DisplayEventHandler |
| CThreadSafeRenderEventHandler | A thread-safe subclass of RenderEventHandler |
| CTlasCreateInfo | |
| CTlasId | |
| CVertexAlloc | |
| CVertexComponent | Describes a single vertex component in a vertex layout description |
| CVertexLayoutCreateInfo | |
| CVertexLayoutId | |
| CVertexLayoutInfo | |
| CVertexStream | |
| CWindowCreateInfo | |
| CWindowId | |
| NDarwin | |
| CDarwinSystemInfo | Provide information about the system we're running on |
| CDarwinTimer | Darwin implementation of the Time::Timer class |
| NDb | |
| CColumn | Describes a column in a database table |
| CCommand | Wraps a general SQL command |
| CDatabase | Wraps an entire database into a C++ object |
| CDataset | A dataset is an efficient in-memory-cache for rlational database data |
| CDbFactory | DbFactory object for the Db subsystem |
| CDbServer | Provides highlevel access to the world database |
| CFilterSet | Implements a filter for datatbase data using a condition tree |
| CToken | |
| CReader | Wrapper to bulk-read the contents of a database table |
| CRelation | A Relation object describes a relation between 2 tables which are linked through a common attribute |
| CSqlite3Command | SQLite3 implementation of Db::Command |
| CSqlite3Database | SQLite3 implementation of Db::Database |
| CSqlite3Dataset | SQLite implemention of Dataset |
| CSqlite3Factory | Creates Db objects derived for the Sqlite3 Db wrapper |
| CSqlite3FilterSet | |
| CSqlite3Table | |
| CTable | Describes a table in a database, or more abstract, a set of typed columns grouped under a common name |
| CValueTable | A table of database values |
| CWriter | A wrapper class to bulk-write data to the database in a simple way |
| NDebug | |
| C[struct].state | |
| CConsolePageHandler | Print console output to HTML page |
| CCorePageHandler | Provide information about Core subsystem to debug http server |
| CDebugCounter | A debug counter for counting events |
| CDebugFloat | This class is supposed to make it easier, to restore the exact value of floating- point-based types, like vector, mat4, float etc |
| CDebugHandler | The message handler for the debug interface |
| CDebugInterface | Interface object of the Debug subsystem |
| CDebugPageHandler | Http request handler for the Debug subsystem |
| CDebugServer | The debug server singleton is visible from all threads and keeps track of debug timer and debug counters |
| CDebugTimer | A debug timer for measuring time spent in code blocks |
| CDisplayPageHandler | Provide information about the display to the debug http server |
| CFrameScriptInspector | |
| CHelloWorldRequestHandler | Most simple HttpRequestHandler possible |
| CIoPageHandler | Provide information about IO subsystem to debug http server |
| CMemoryPageHandler | Provide information about memory allocations to debug http server |
| CMeshPageHandler | Provide an HTML debug page with information about shared mesh resources |
| CShaderPageHandler | Provide a HTML debug page for shaders |
| CStringAtomPageHandler | |
| CSvgTestPageHandler | A HTTP test page handler to test SVG rendering functionality |
| CTexturePageHandler | Provide a HTML debug page with information about all shared texture resources |
| CThreadPageHandler | Displays info about currently running Nebula threads |
| NDecals | The Decal context manages the decal system and entities and rendering |
| C[struct].decalState | |
| CDecalContext | |
| NDynui | Imgui Profiler UI |
| CGraph | Time Graph with predefined amount of entries |
| CImguiAddon | (C) 2012-2016 Individual contributors, see AUTHORS file |
| CImguiConsole | The ImGui console uses ImGui to produce a live interactive console |
| CLogEntry | |
| CImguiConsoleHandler | Consolehandler that prints its output to the imgui console |
| CImguiContext | |
| CImguiDisplayEventHandler | Handles display events such that ImGui is made aware of them |
| CImguiInputHandler | This input handler passes input events to Imgui |
| CImguiProfiler | |
| CImguiRTPlugin | |
| CImGuiSecondaryWindowData | |
| CImguiState | |
| CImguiTextureId | |
| CImGuiWindowHandle | |
| NFibers | Fiber implementation header |
| CFiber | |
| Cfiber_ctx_t | |
| Cfiber_t | |
| CFiberContext | |
| CFiberQueue | |
| CJob | |
| CFiberQueueCreateInfo | |
| CFiberThread | |
| CFiberWaitContext | |
| NFlat | Flatbuffer to Nebula type conversion functions |
| CFlatbufferInterface | |
| NFog | |
| C[struct].blurState | |
| C[struct].fogState | |
| CVolumetricFogContext | |
| NFrame | ImGUI debug interface for inspecting frame scripts |
| CFrameBarrier | |
| CCompiledImpl | |
| CFrameBatchType | Frame batch type hints for the render device and render targets |
| CFrameBlit | |
| CCompiledImpl | |
| CFrameCode | |
| CCompiledImpl | |
| CFrameCompute | |
| CCompiledImpl | |
| CFrameCopy | |
| CCompiledImpl | |
| CFrameEvent | |
| CFrameMipmap | |
| CCompiledImpl | |
| CFrameOp | |
| CBufferSubresourceDep | |
| CTextureSubresourceDep | |
| CCompiled | |
| CTextureDependency | |
| CBufferDependency | |
| CBuildContext | |
| CFramePass | |
| CCompiledImpl | |
| CFramePlugin | |
| CCompiledImpl | |
| CFrameResolve | |
| CCompiledImpl | |
| CFrameScript | A FrameScript describes render operations being done to produce a single frame |
| CFrameScriptLoader | |
| CFrameServer | |
| CFrameSubgraph | |
| CCompiledImpl | |
| CFrameSubmission | |
| CCompiledImpl | |
| CFrameSubpass | |
| CCompiledImpl | |
| CFrameSubpassBatch | |
| CCompiledImpl | |
| CFrameSubpassFullscreenEffect | |
| CCompiledImpl | |
| CFrameSubpassOrderedBatch | |
| CCompiledImpl | |
| CFrameSubpassPlugin | |
| CCompiledImpl | |
| CFrameSwap | |
| CCompiledImpl | |
| CTextureExport | |
| CTextureImport | |
| NFrameSync | |
| CFrameSyncTimer | A thread-local time source object which is synchronized with the sync point in the FrameSyncHandlerThread |
| NGame | Resolves local hierarchical transforms into the mandatory world transform components |
| CAngularVelocity | |
| CTraits | |
| CComponentDecayBuffer | Contains data for components flagged with COMPONENTFLAG_DECAY, that has been deleted this frame |
| CComponentInspection | Component inspection functions |
| CComponentInterface | These are registered to the attribute registry so that we can add more functionality to attributes |
| CComponentRegisterInfo | Used for registering component types to the game world |
| CComponentSerialization | Component serialization functions |
| CSerializer | |
| CDataset | A dataset that contains views into category tables |
| CView | This represents a "view" into an entity table |
| CEditorState | |
| CEntity | An entity is essentially just an Id with some utility functions attached |
| CTraits | |
| CEntityMapping | Maps an entity to a table and instance id |
| CEntityPool | Generation pool |
| CEntityTableCreateInfo | |
| CFeatureUnit | A FeatureUnit is an encapsulated feature which can be added to an application |
| CFilterBuilder | |
| CComponentRequest | |
| CFilterCreateInfo | |
| CFrameEvent | |
| CBatch | A batch of frame callbacks |
| CFramePipeline | |
| CGameServer | The game server setups and runs the game world |
| CState | Internal state and world management |
| CHierarchyManager | |
| CManager | Managers are objects which care about some specific functionality of a feature |
| CMessage | |
| CMessageQueueId | |
| CMessageListener | |
| CMessageListenerId | |
| COrientation | A component that stores the orientation of an entity |
| CTraits | |
| CPackedLevel | Represents a level that can be instantiated into a world |
| CEntityGroup | |
| CPosition | A component that stores the position of an entity in world space coordinates |
| CTraits | |
| CProcessor | |
| CProcessorBuilder | |
| CProcessorJobContext | |
| CProcessorJobInput | |
| CScale | A component that stores the scale of an entity |
| CTraits | |
| CTimeManager | Singleton object which manages all Game::TimeSource objects |
| CTimeSource | An object that keeps track of running time and frame time (delta time) |
| CTimeSourceCreateInfo | Used to create a timesource |
| CVelocity | A component that stores the linear velocity of an entity |
| CTraits | |
| CWorld | A container of entities, their components, and processors |
| CAllocateInstanceCommand | |
| CDeallocInstanceCommand | |
| CAddStagedComponentCommand | |
| CRemoveComponentCommand | |
| CWorldHash | |
| NGcc | |
| CGccInterlocked | Provides simple atomic operations on shared variables using gcc compiler builtins |
| NGI | The DDGI context is responsible for managing the GI volumes used to apply indirect light in the scene |
| C[struct].state | |
| CDDGIContext | |
| CVolumeSetup | |
| CVolume | |
| CDDGIOptions | |
| C[struct].flags | |
| NGLFW | |
| CGLFWDisplayDevice | |
| CGLFWInputServer | |
| NGraphics | Implements the shader server used by Vulkan |
| C[struct].envState | |
| C[struct].globalConstantState | |
| C[union]DirtySet.globalConstantState.__unnamed0__ | |
| C[struct].state | |
| CBindlessRegistryCreateInfo | |
| CCameraContext | Handles cameras |
| CCameraSettings | |
| CContextEntityId | |
| CDepthOfField | |
| CEnvironmentContext | The environment context deals with anything related to the sky and atmosphere effects |
| CFrameContext | |
| CGlobalConstantsCreateInfo | |
| CGraphicsContext | |
| CGraphicsContextFunctionBundle | |
| CGraphicsContextState | A graphics context is a resource which holds a contextual representation for a graphics entity |
| CGraphicsDisplayEventHandler | Handles DisplayEvents that are relevant for the graphics system |
| CGraphicsEntityId | The graphics entity is only an Id, to which we can attach GraphicsContexts |
| CGraphicsServer | The graphics server is the main singleton for the Graphics subsystem |
| CLightProbeContext | Adds a light probe component to graphics entities |
| CViewCreateInfo | |
| CViewId | |
| NGraphicsFeature | |
| CCameraManager | Handles camera related properties |
| CViewData | |
| CGraphicsFeatureUnit | Sets up the core rendering system and provides properties and managers for default usage, such as rendering models, animations, particles, etc |
| CGraphicsManager | Handles logic for connecting the game layer with the render layer |
| NHttp | This file was generated with Nebula Trifid's idlc compiler tool |
| CAttachRequestHandler | |
| CDefaultHttpRequestHandler | This implements the "Home Page" of the Nebula application |
| CHtmlElement | HTML markup elements |
| CHtmlPageWriter | A stream writer which supports writing a HTML-formatted page into a stream |
| CHttpClient | Use a HTTP client to send HTTP requests to a HTTP server, and receive and decode HTTP responses |
| CHttpClientRegistry | 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 |
| CConnection | |
| CHttpInterface | The HttpInterface launches the HttpServer thread and is the communication interface with the HttpServer thread |
| CHttpMessageHandler | Runs the HttpServer thread, and owns the central http server |
| CHttpMethod | Http methods enumeration (GET, PUT, etc...) |
| CHttpNzStream | A version of HttpStream which reads .nz compressed files as created by the Nebula archiver tool |
| CHttpRequest | Encapsulates a complete Http request into a message |
| CHttpRequestHandler | HttpRequestHandlers are attached to the HttpServer and process incoming HTTP requests |
| CHttpRequestReader | A stream reader which cracks a HTTP request into its components |
| CHttpRequestWriter | Writes a valid HTTP request header to a stream |
| CHttpResponseReader | Decodes a response header from a HTTP server and optionally writes received content data to a provided stream |
| CHttpResponseWriter | Stream writer which writes a correct HTTP response to a stream |
| CHttpServer | Implements an extremly simple standalone HTTP server with attached HttpRequestHandlers |
| CPendingRequest | |
| CHttpServerProxy | Client-side proxy of the HttpServer |
| CHttpStatus | HTTP status code enumeration (e.g |
| CHttpStream | Wraps client HTTP requests to a HTTP server into an IO::Stream |
| CNebulaHttpClient | |
| CRemoveRequestHandler | |
| CSvgLineChartWriter | Specialized SVG page writer which draws a line chart diagrams |
| CTrack | |
| CSvgPageWriter | A stream writer to generate simple SVG pages |
| NIds | This simple Id pool implements a set of free and used consecutive integers |
| CId | 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 |
| CIdAllocator | An ID allocator associates an id with a slice in an N number of arrays |
| CIdAllocatorSafe | |
| CIdGenerationPool | Provides a system for creating array friendly id numbers with reuse and generations |
| CIdPool | |
| NIm3d | |
| Ninternal | |
| CScalarT | |
| CFloatT | |
| CIntT | |
| CCompositeT | |
| CVecT | |
| CMatT | |
| CTypeTraits | |
| CTypeTraits< int > | |
| CTypeTraits< float > | |
| CTypeTraits< Vec2 > | |
| CTypeTraits< Vec3 > | |
| CTypeTraits< Vec4 > | |
| CTypeTraits< Mat4 > | |
| CAppData | |
| CCapsule | |
| CColor | |
| CContext | |
| CDrawList | |
| CIm3dContext | |
| CIm3dState | |
| CLine | |
| CLineSegment | |
| CMat3 | |
| CMat4 | |
| CPlane | |
| CRay | |
| CSphere | |
| CTextData | |
| CTextDrawList | |
| CVec2 | |
| CVec3 | |
| CVec4 | |
| CVector | |
| CVertexData | |
| NInput | FIXME! |
| CInputDisplayEventHandler | Translates DisplayEvents that are relevant for the input system into InputEvents |
| CInputEvent | The input events of the Input subsystems |
| CInputHandler | Input handlers receive and process input events |
| CInputPriority | Input priorities for input handlers |
| CInputServer | The InputServer is the central object of the Input subsystem |
| CKey | Define standard key codes |
| CMouse | An input handler which represents a mouse for polling |
| CMouseButton | Mouse button codes and conversion from/to string |
| NInterface | |
| CInterfaceBase | Base class for interfaces |
| CInterfaceHandlerBase | Base class for message handlers attached to Interface objects |
| NIO | Instances of wrapped stream classes |
| CArchiveBase | Base class of file archives |
| CArchiveFileSystemBase | |
| CAssign | An assign associates an intuitive name with a real-world filesystem path |
| CAssignRegistry | Central registry for path assigns |
| CBinaryReader | A friendly interface to read binary data from a stream |
| CBinaryWriter | A friendly interface for writing binary data to a stream |
| CBXMLFileAttr | |
| CBXMLFileHeader | |
| CBXMLFileNode | |
| CBXmlLoaderUtil | Helper class for loading binary xml files created with N3's binaryxmlconverter3 tool |
| CBXmlReader | Stream reader for binary XML files |
| CCachedHttpStream | |
| CCachedStream | Wraps an underlying mappable stream object to avoid reopening it more than once (e |
| CConsole | Nebula's console, this is the central place for command- line-style communication with the user |
| CConsoleHandler | Base class for all console handlers |
| CEmbeddedMemoryStream | Implements a stream class which reads from an embedded resource |
| CEventHandlerData | |
| CExcelXmlReader | A stream reader class which reads Excel XML files |
| CFileStream | A stream to which offers read/write access to filesystem files |
| CFileWatcher | For registering callbacks for file modification events |
| CFileWatcherImpl | |
| CFileWatcherPlatform | |
| CHistoryConsoleHandler | A console handler which stores the last N log messages in a Util::RingBuffer<String> |
| CIoInterface | |
| CIoServer | The central server object of the IO subsystem offers the following services: |
| CIOStat | |
| CJsonReader | Reads json formatted data with random access from a stream using pjson as backend |
| CJsonWriter | Write Json-formatted data to a stream |
| CLogFileConsoleHandler | A console handler which writes all console output to a log file |
| CMediaType | Encapsulates a MIME conformant media type description (text/plain, image/jpg, etc...) |
| CMemoryStream | Implements a stream class which writes to and reads from system RAM |
| CPath | A path is an abstraction around file paths |
| CSafeFileStream | Wrapper around FileStream that will save to a temporary file and swap when closed |
| CSchemeRegistry | Central registry for URI schemes, associates an URI scheme (e.g |
| CStream | Offers an abstract interface for read/write access to a sequence of bytes |
| CStreamCache | Explicit cache for reusing read-only streams that are already opened |
| CCacheEntry | |
| CStreamReader | Stream reader classes provide a specialized read-interface for a stream |
| CStreamWriter | Stream writer classes provide a specialized write-interface for a stream |
| CTextReader | A friendly interface for reading text data from a stream |
| CTextWriter | A friendly interface for writing text data to a stream |
| CURI | An URI object can split a Uniform Resource Identifier string into its components or build a string from URI components |
| CURN | A URN (Uniform Resource Name) is a URI (Uniform Resource Identifier) that uses the "urn" scheme |
| CWatchEvent | |
| CXmlReader | Reads XML formatted data with random access from a stream using TinyXML as backend |
| CTinyXmlInitHelper | Static helper object for TinyXml-Initialization at application startup |
| CXmlWriter | Write XML-formatted data to a stream |
| CZipArchive | Private helper class for ZipFileSystem to hold per-Zip-archive data |
| CZipDirEntry | A directory entry in a zip arcive |
| CZipFileEntry | A file entry in a zip archive |
| CZipFileStream | Wraps a file in a zip archive into a stream |
| CZipFileSystem | An archive filesystem wrapper for ZIP files |
| NJobs | Job system allows for scheduling and execution of a parallel task |
| CJobFuncContext | This class describes the size of a workload for a single thread (can be multiple items) |
| CJobIOData | |
| CJobUniformData | |
| CJobContext | |
| CJobThread | |
| CJobThreadCommand | |
| C[union].__unnamed0__ | |
| C[struct].__unnamed0__.run | |
| C[struct].__unnamed0__.sync | |
| CJobId | |
| CJobPortId | |
| CJobSyncId | |
| CCreateJobPortInfo | |
| CCreateJobInfo | |
| CPrivateMemory | |
| CCreateJobSyncInfo | |
| NJobs2 | |
| CCallableStub | |
| CCallable | |
| CLambda | |
| CJobContext | |
| CJobNode | |
| CJobs2Context | |
| CJobThread | |
| CJobSystemInitInfo | |
| NLighting | The lighting subsystem allows for attaching light source functionality to a GraphicsEntityId |
| C[struct].clusterState | |
| C[struct].combineState | |
| C[struct].lightServerState | |
| C[struct].textureState | |
| CLightContext | |
| CDirectionalLightSetupInfo | |
| CPointLightSetupInfo | |
| CSpotLightSetupInfo | |
| CAreaLightSetupInfo | |
| CConstantBufferSet | |
| CShadowData | |
| NLinux | |
| CLinuxCompletionCounter | Block a thread until count reaches 0 |
| CLinuxEvent | Linux implementation of Event |
| CLinuxRendezvous | A thread barrier for 2 threads using semaphores |
| CLinuxThread | Linux implementation of Threading::Thread |
| CLinuxThreadLocalData | Thread local data storage class for platforms which don't have a proper __thread implementation but a pthread implementation |
| CLinuxThreadLocalPtr | A thread-local pointer class for platforms which don't have proper support for the __thread keyword |
| NMaterials | Material special version of variant |
| C[struct].materialLoaderState | |
| C[union]DirtySet.materialLoaderState.dirtySet | |
| CMaterialBuffer | |
| CMaterialConstant | |
| CMaterialId | |
| CMaterialInstanceId | |
| CMaterialLoader | |
| CMaterialTexture | |
| CMaterialVariant | |
| CShaderConfigBatchTexture | |
| NMaterialTemplates | Materials represent a set of settings and a correlated shader configuration, which tells the engine which shader to use and how to apply the constants and textures on each respective shader |
| CMaterialTemplateValue | |
| C[union].data | |
| CMaterialTemplateTexture | |
| CEntry | |
| CPass | |
| NMaterialTemplatesGPULang | |
| CMaterialTemplateValue | |
| C[union].data | |
| CMaterialTemplateTexture | |
| CEntry | |
| CPass | |
| NMath | Different curves |
| CAngularPFeedbackLoop | A proportional feedback loop with correct angular interpolation |
| Cbbox | Nebula's bounding box class |
| CBezierCubic | |
| Cbyte4 | |
| C[union].__unnamed0__ | |
| C[struct].__unnamed0__.__unnamed0__ | |
| Cbyte4u | |
| C[union].__unnamed0__ | |
| C[struct].__unnamed0__.__unnamed0__ | |
| CClipStatus | The result of a clip check (Inside, Outside or Clipped) |
| CExtrapolator | Extrapolator maintains state about updates for remote entities, and will generate smooth guesses about where those entities will be based on previously received data |
| Cfloat2 | |
| C[union].__unnamed0__ | |
| C[struct].__unnamed0__.__unnamed0__ | |
| Cfloat3 | |
| C[union].__unnamed0__ | |
| C[struct].__unnamed0__.__unnamed0__ | |
| Cfloat4 | |
| C[union].__unnamed0__ | |
| C[struct].__unnamed0__.__unnamed0__ | |
| Cfrustum | Defines a clipping frustum made of 6 planes |
| Chalf | |
| CFloat | |
| C[struct].ieee | |
| Cint2 | |
| C[union].__unnamed0__ | |
| C[struct].__unnamed0__.__unnamed0__ | |
| Cint3 | |
| C[union].__unnamed0__ | |
| C[struct].__unnamed0__.__unnamed0__ | |
| Cint4 | |
| C[union].__unnamed0__ | |
| C[struct].__unnamed0__.__unnamed0__ | |
| Cline | A line in 3d space |
| Cmat4 | A 4x4 single point precision float matrix |
| C[union].__unnamed0__ | We use aliasing to represent the matrix in may different ways |
| C[struct].__unnamed0__.__unnamed0__ | |
| C[struct].__unnamed0__.__unnamed1__ | Float accessors |
| C[struct].__unnamed0__.__unnamed2__ | Array accessible rows |
| Cnoise | Perlin noise class |
| CPFeedbackLoop | 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 |
| CPIDFeedbackLoop | A PID feedback loop (proportional integral derivative feedback loop) |
| Cplane | A mathematical plane represented by a normal and a distance from origin |
| C[union].__unnamed0__ | |
| C[struct].__unnamed0__.__unnamed0__ | |
| C[struct].__unnamed0__.__unnamed1__ | |
| Cpoint | Represents a 3D point in space |
| C[union].__unnamed0__ | |
| C[struct].__unnamed0__.__unnamed0__ | |
| Cpolar | A polar coordinate inline class, consisting of 2 angles theta (latitude) and rho (longitude) |
| Cquat | A quaternion is usually used to represent an orientation in 3D space |
| C[union].__unnamed0__ | |
| C[struct].__unnamed0__.__unnamed0__ | |
| Crandxorstate | Fast random generator based on xorshift+ |
| Crectangle | A 2d rectangle class |
| Csphere | A 3-dimensional sphere |
| Ctransform | Simple transform using position, quaternion, and scale |
| Ctransform44 | A 4x4 matrix which is described by translation, rotation and scale |
| Cuint2 | |
| C[union].__unnamed0__ | |
| C[struct].__unnamed0__.__unnamed0__ | |
| Cuint3 | |
| C[union].__unnamed0__ | |
| C[struct].__unnamed0__.__unnamed0__ | |
| Cuint4 | |
| C[union].__unnamed0__ | |
| C[struct].__unnamed0__.__unnamed0__ | |
| Cvec2 | A 2-component float vector class |
| Cvec3 | A 3D vector |
| C[union].__unnamed0__ | |
| C[struct].__unnamed0__.__unnamed0__ | |
| Cvec4 | A 4D vector |
| C[union].__unnamed0__ | |
| C[struct].__unnamed0__.__unnamed0__ | |
| Cvector | A vector is a 3D direction in space |
| C[union].__unnamed0__ | |
| C[struct].__unnamed0__.__unnamed0__ | |
| NMemDb | Attribute |
| CAttribute | |
| CAttributeId | |
| CAttributeRegistry | |
| CColumnIndex | Column id |
| CDatabase | |
| CDataset | |
| CView | A view into a category table |
| CFilterSet | |
| CRowId | Row identifier |
| CTable | A table of columns (attributes) and rows |
| CPartition | Represents a partition within a Table in MemDb |
| CTableCreateInfo | Information for creating a table |
| CTableId | Table identifier |
| CTableSignature | Basically a bitfield with packed ComponentIds |
| NMemory | |
| CArenaAllocator | Allocates memory in chunks |
| CPoolArrayAllocator | Allocates small memory blocks from an array of fixed-size memory pools |
| CRangeAllocation | Describes a range allocated by the Memory::RangeAllocator |
| CRangeAllocator | Allocates memory ranges using the TLSF method, with extended handling of padding to better suit GPUs |
| CRangeAllocatorNode | |
| CBinIndex | |
| CRingAlloc | |
| CRingAllocator | Allocates memory up-front, and then allows other systems to grab regions |
| CInterval | |
| CTotalMemoryStatus | Get the system's total current memory, this does not only include Nebula's memory allocations but the memory usage of the entire system |
| NMessaging | |
| CAsyncPort | Runs its handlers in a separate thread, so that message processing happens in a separate thread and doesn't block the main thread |
| CBatchMessage | A batch of messages which is itself a message |
| CBlockingHandlerThread | Message handler thread class which blocks until messages arrive (or optionally, a time-out occurs) |
| CDelegateTable | Associates message ids with handler delegates |
| CDispatcher | A message Dispatcher is a specialization of a message Port |
| CHandler | Message handlers are used to process a message |
| CHandlerThreadBase | Base class for AsyncPort message handler thread classes |
| CId | A message identifier |
| CMessage | Messages are packets of data which can be sent to a message port |
| CMessageCallbackHandler | Handles asynchronous message callbacks |
| CMessageReader | Implements a binary stream protocol for decoding messages from a stream |
| CMessageWriter | Implements a binary stream protocol for encoding messages into streams |
| CPort | A message port is a receiving point for messages |
| CRunThroughHandlerThread | A simple handler thread class which "runs thru", and doesn't wait for messages |
| CStaticMessageHandler | Implements a simple, static message handler helper class |
| NModels | A model resource consists of nodes, each of which inhibit some information read from an .n3 file |
| CCharacterNode | |
| CCharacterSkinNode | |
| CFragment | Skin fragment |
| CJointMask | |
| CModelContext | |
| CNodeInstanceState | |
| CModelInstance | |
| CTransformable | Transforms are only used by the model context to traverse and propagate the transform hierarchy |
| CRenderable | The bounding boxes are used by visibility and the states by rendering |
| CMaterialInstanceContext | |
| CModelCreateInfo | |
| CModelId | |
| CModelLoader | |
| CModelNode | |
| CModelStreamingData | |
| CNodeInstanceRange | |
| CParticleSystemNode | |
| CPrimitiveNode | |
| CLoadContext | |
| CShaderStateNode | |
| CDrawPacket | |
| CTake | |
| CClip | |
| CEvent | |
| CTransformNode | |
| NMultiplayer | |
| CBaseMultiplayerClient | |
| CBaseMultiplayerServer | |
| CClientConnection | |
| CClientProcessorContext | |
| CMultiplayerFeatureUnit | |
| CServerProcessorContext | |
| CStandardMultiplayerClient | |
| CStandardMultiplayerServer | |
| NNavigation | Navigation::Recast |
| CAgentContext | |
| CCrowdAgentId | |
| CDebugDraw | |
| CNavigationPageHandler | Provide information about the navigation system |
| CNavMeshId | |
| CStreamNavMeshCache | |
| NNavigationFeature | |
| CNavigationFeatureUnit | |
| CNavigationManager | |
| CPids | |
| NNebula | |
| NGame | |
| CComponentManager | |
| CEntity | Represents a game object that resides in a game world |
| CEntityId | |
| CIMessageHandler< T > | |
| CINebulaApi | |
| CMsg | |
| CMsgDispatcher | |
| CIMessageChannel | |
| CMessageChannel< T > | |
| CNativeComponent | All structs that inherit from this class will automatically be registered and searchable as native components |
| CNebulaApiV1 | |
| CNebulaApp | |
| CProperty | |
| CPropertyManager | |
| CResourceDescriptor | Represents a native descriptor for a resource name |
| CWorld | |
| CBoundingBox | |
| CBoundingFrustum | Defines a viewing frustum for intersection operations |
| CBoundingSphere | Describes a sphere in 3D-space for bounding operations |
| CColor | Describes a 32-bit packed color |
| CDebug | |
| CMathf | Contains commonly used precalculated values and mathematical operations |
| CMatrix | Represents the right-handed 4x4 floating point matrix, which can store translation, scale and rotation information |
| CPlane | |
| CPlaneHelper | |
| CPoint | Describes a 2D-point |
| CQuaternion | An efficient mathematical representation for three dimensional rotations |
| CRay | |
| CRectangle | Describes a 2D-rectangle |
| CRuntime | |
| CRuntimeData | |
| CVector2 | Describes a 2D-vector |
| CVector3 | Describes a 3D-vector |
| CVector4 | Describes a 4D-vector |
| NNebulaEngine | |
| CAppEntry | |
| NNet | |
| CDebugMessage | Encapsulates a stream and a port number for debug communication |
| CDebugPacket | Encapsulates a data packet for debug communication |
| CMessageClient | Wrapper class for the Net::TcpClient that sends data in special message container |
| CMessageClientConnection | A wrapper class for the Net::TcpClientConnection |
| CStdTcpClient | A TcpClient object is used to communicate with a TcpServer |
| CStdTcpClientConnection | A TcpClientConnection represents a connected TcpClient on the server side |
| CStdTcpServer | A TcpServer opens a socket and listens for connecting TcpClients |
| CListenerThread | Private listener thread class |
| CTcpMessageCodec | Helperclass that provides function to encode and decode sreams into messages |
| NOSX | |
| COSXConsoleHandler | The default console handler for OSX, puts messages to stdout and stderr, reads from stdin |
| COSXCpu | CPU related definitions for the MacOSX platform |
| COSXCriticalSection | On OSX, pthread mutexes are used for critical sections |
| COSXFileTime | Wraps file-system related timestamps on OSX |
| COSXFSWrapper | Internal filesystem wrapper for the OSX |
| COSXGuid | OSX implementation of the Util::Guid class |
| COSXHeap | OSX implementation of Memory::Heap |
| COSXMemoryPool | FIXME: IMPLEMENT ME! |
| COSXThread | OSX implementation of Threading::Thread |
| COSXThreadLocalPtr | GCC doesn't implement the __thread modifier on OSX |
| CSysFunc | Lowest-level functions for OSX platform |
| NParticles | Particle context controls playing and enabling/disabling of particle attrs inside a model |
| C[struct].state | |
| CEmitterAttrs | A container for particle emitter attributes |
| CIntAttributes | |
| CBoolAttributes | |
| CEmitterMesh | An emitter mesh holds positions and normals for particle emission |
| CEmitterPoint | |
| CEnvelopeCurve | An Attack/Sustain/Release envelope curve class with optional sine/cosine modulation |
| CEnvelopeSampleBuffer | A lookup table for pre-sampled envelope curves |
| CParticle | The particle structure holds the current state of a single particle and common data for particle-job and nebula3 particle system |
| CParticleContext | |
| CParticleRuntime | |
| CParticleJobOutput | |
| CParticleSystemRuntime | |
| CParticleEmitters | |
| CParticleJobContext | |
| CParticleJobSliceOutputData | |
| CParticleJobUniformData | |
| CParticleLoader | |
| CParticleResourceId | |
| NPhysics | Diverse functions for manipulating physics actors |
| CActor | |
| CActorContext | |
| CActorId | |
| CActorInfo | |
| CActorResourceId | |
| CAggregate | |
| CAggregateContext | |
| CAggregateId | |
| CAggregateInfo | |
| CAggregateResourceId | |
| CAllocator | |
| CBodyInfo | |
| CCharacter | |
| CCharacterContext | |
| CCharacterCreateInfo | |
| CCapsuleInfo | |
| CBoxInfo | |
| C[union].__unnamed0__ | |
| CCharacterId | |
| CConstraint | |
| CConstraintId | |
| CConstraintInfo | |
| CConstraintResourceId | |
| CContactEvent | |
| CDebugDrawInterface | |
| CDebugState | |
| CErrorCallback | |
| CMaterial | |
| CPhysicsResourceId | |
| CPhysxState | |
| CScene | Physx scene classes, foundation and physics are duplicated here for convenience instead of static getters, might be removed later on |
| CShapeHandle | |
| CStreamActorPool | |
| CVisualDebugger | Class that communicates with the physics visual debugger program |
| CTimedDrawData | Base class for draw-calls that should be done over a number of steps |
| NPhysicsFeature | |
| CCharacterManager | |
| CPhysicsFeatureUnit | Sets up and interfaces with the physics subsystem |
| CPhysicsManager | |
| NPicking | |
| CPickingServer | Server responsible to handle id-based rendering |
| NPosix | Posix implemention of a read-many write-few lock |
| CPosixCalendarTime | Posix implementation of CalendarTime |
| CPosixConsoleHandler | The default console handler for Posix, puts normal messages to the debug output channel, and error messages into a message box |
| CPosixCpu | CPU related definitions for the Posix platform |
| CPosixCriticalSection | Posix-implementation of critical section |
| CPosixEnvironment | Provides read-access to environment variables |
| CPosixEvent | Posix implmentation of an event synchronization object |
| CPosixFileTime | Implements a Posix-specific file-access time stamp |
| CPosixFSWrapper | Internal filesystem wrapper for Posix |
| CPosixGuid | Posix implementation of the Util::Guid class |
| CPosixHeap | Posix implementation of the class Memory::Heap using the Posix-Heap functions |
| CPosixIpAddress | Represents an IP address, consisting of a IPv4 host address and a port number |
| CPosixLibrary | Load and handle an external shared library on POSIX platforms |
| CPosixMemoryPool | FIXME: IMPLEMENT ME! |
| CPosixProcess | |
| CPosixReadWriteLock | |
| CPosixSettings | A simple wrapper class to store config files in the users home directory Uses Boosts Property_tree library for the time being |
| CPosixSocket | A lowlevel socket wrapper class |
| CPosixSystemInfo | Provide information about the system we're running on |
| CPosixThread | Posix implementation of thread class |
| CPosixThreadBarrier | Block until all thread have arrived at the barrier |
| CPosixTimer | Posix implementation of the Time::Timer class |
| CSysFunc | Provides Posix specific helper functions |
| NPostEffects | Bloom post effect |
| C[struct].bloomState | |
| C[struct].dofState | |
| C[struct].histogramState | |
| C[struct].ssaoState | |
| C[struct]AOVariables.ssaoState.vars | |
| C[struct].ssrState | |
| C[struct].state | |
| CBloomContext | |
| CDofContext | |
| CDownsamplingContext | |
| CHistogramContext | |
| CSSAOContext | |
| CSSRContext | |
| CViewData | |
| NProfiling | |
| CProfilingScope | |
| CProfilingScopeLock | Convenience class used to automatically push and pop scopes |
| CProfilingContext | Thread context of profiling |
| NRaytracing | Context dealing with scene management for ray tracing |
| C[struct].state | |
| CRaytracingContext | |
| CRaytracingSetupSettings | |
| NRenderModules | |
| CRenderModule | A RenderModule wraps a specific, optional, rendering functionality into a simple object which only requires a simple setup |
| CRTPlugin | Standard interface to add new functionality to the render thread |
| CRTPluginRegistry | The central registry for render thread plugins |
| NRenderUtil | Helpers to create geometry |
| CDrawFullScreenQuad | Actually draws one big triangle which covers the entire screen, which is more efficient than drawing a quad using two triangles |
| CFreeCameraUtil | Implements a free camera |
| CGeometry | |
| CGeometryHelpers | |
| CMayaCameraUtil | Helper class to implement a "Maya camera" with pan/zoom/orbit |
| CMouseRayUtil | Helper class to compute a world-space ray from mouse coords |
| CNodeLookupUtil | Helper class to find specific nodes and nodeinstances inside a graphicsentity |
| NResources | A resource is a container for some type of file which is loaded |
| CResource | |
| CResourceLoader | |
| C_PendingResourceLoad | Struct for pending resources which are about to be loaded |
| C_LoadMetaData | |
| C_StreamData | |
| CResourceInitOutput | |
| CResourceStreamOutput | |
| CLoadState | |
| CResourceLoadJob | |
| CResourceLoadOutput | |
| C_PendingStreamLod | Struct for pending stream |
| C_PendingResourceUnload | |
| C_Callbacks | Callback functions to run when an associated resource is loaded (can be stacked) |
| C_PlaceholderResource | |
| CResourceLoaderThread | |
| CResourceSaver | |
| CResourceServer | |
| CResourceUnknownId | |
| NScripting | |
| CAssemblyId | |
| CDotNET_API | |
| CNSharpServer | C# backend for the Nebula scripting subsystem |
| CAssembly | |
| CScriptFeatureUnit | |
| NStaticUI | Static UI Context |
| C[struct].state | |
| C[struct].ultralightState | |
| CLogger | |
| CStaticUIContext | |
| CUltralightRenderer | |
| CTextureHandle | |
| CRenderBufferHandle | |
| CGeometryHandle | |
| Nstd | |
| Cnumeric_limits< Math::half > | |
| NSystem | |
| CByteOrder | Provides information and methods to help with byte ordering issues |
| CPunFloatUL | |
| CPunDoubleULL | |
| CCpu | Provides information about the system's CPU(s) |
| CProcessId | |
| CProcessStartInfo | |
| NTBUI | Turbobadger UI Batch |
| CTBUIBatch | |
| CTBUIBitmap | |
| CTBUIClipboardInterface | |
| CTBUIContext | |
| CTBUIState | |
| CTBUIFile | |
| CTBUIFileInterface | |
| CTBUIInputHandler | This input handler passes input events to Turbobadger |
| CTBUIRenderer | |
| CTBUISTBFontRenderer | STBFontRenderer renders fonts using stb_truetype.h (http://nothings.org/) |
| CTBUISystemInterface | |
| CTBUIVertex | |
| CTBUIView | |
| NTerrain | A quad tree designed to return regions of free 2D space |
| C[struct].raytracingState | |
| C[struct].terrainState | |
| C[struct].terrainVirtualTileState | |
| CBiomeMaterial | |
| CBiomeMaterialBuilder | |
| CBiomeParameters | |
| CBiomeSettings | |
| CBiomeSettingsBuilder | |
| CIndirectionEntry | |
| COccupancyQuadTree | |
| CNode | |
| CPhysicalTileUpdate | |
| CSubTexture | |
| CSubTextureCompressed | |
| CSubTextureUpdateJobOutput | |
| CSubTextureUpdateJobUniforms | |
| CTerrainBiomeId | |
| CTerrainContext | |
| CTerrainLoadInfo | |
| CTerrainRuntimeInfo | |
| CTerrainInstanceInfo | |
| CTerrainCreateInfo | |
| CTerrainQuad | |
| CTerrainSetupSettings | |
| CTerrainTri | |
| CTerrainVert | |
| CTextureTileCache | |
| CCacheResult | |
| CNode | |
| CTileCacheEntry | |
| CEntry | |
| C[union].__unnamed0__ | |
| NThreading | The Jobs2 system provides a set of threads and a pool of jobs from which threads can pickup work |
| NInterlocked | |
| CAtomicInt | |
| CAtomicInt64 | |
| CAtomicPointer | |
| CAtomicCounter | Atomic value only used to decrement, increment and read a 32 bit value |
| CAtomicCounter64 | Atomic value only used to decrement, increment and read a 64 bit value |
| CAssertingMutex | |
| CAssertingScope | |
| CCriticalScope | |
| CEventWithManualReset | |
| CLockFreeQueue | |
| CNode | |
| CObjectRef | A thread-safe reference to a shared object |
| CSafeFlag | A thread-safe flag variable |
| CSafePriorityQueue | A thread-safe priority-sorted queue which protects itself with critical sections |
| CSafeQueue | Thread-safe version of Util::Queue |
| CSpinlock | |
| CSpinlockScope | |
| NUtil | A quad tree designed to return regions of free 2D space |
| C_smallvector | |
| C_smallvector< TYPE, 0 > | |
| CAllocatorLock | |
| CArray | Nebula's dynamic array class |
| CArrayAllocator | 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 |
| CArrayAllocatorSafe | 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 |
| CArrayQueue | |
| CArrayStack | Nebula's small vector optimized array |
| CBitField | Implements large bit field |
| CBitType | |
| CBitType< 16 > | |
| CBitType< 32 > | |
| CBitType< 64 > | |
| CBlob | The Util::Blob class encapsulates a chunk of raw memory into a C++ object which can be copied, compared and hashed |
| CBvh | |
| CNode | |
| CColor | Represents colors by four single point (32-bit) floating point numbers |
| CCommandLineArgs | A universal cmd line argument parser |
| CCrc | Compute CRC checksums over a range of memory |
| CDelegate | Nebula delegate class, allows to store a function, method or lambda call into a C++ object for later execution |
| CDelegate< RETTYPE(ARGTYPES...)> | |
| CDictionary | A collection of key/value pairs with quick value retrieval by key at roughly O(log n) |
| CFixedArray | Implements a fixed size one-dimensional array |
| CFixedPool | Implements a fixed size pool, from which objects of a specific type can be allocated and freed for reuse |
| CFixedTable | A fixed-size 2-dimensional array |
| CFourCC | A four-character-code is a quasi-human-readable 32-bit-id |
| Cget_template_type | |
| Cget_template_type< C< I, T > & > | Get inner type of two types |
| Cget_template_type< C< I, T > > | Get inner type of two types |
| Cget_template_type< C< T > > | Get inner type of two types |
| Cget_template_type< C< T, I > & > | Get inner type of two types |
| Cget_template_type< C< T, I > > | Get inner type of two types |
| Cget_template_type< const C< T > & > | Get inner type of a constant ref outer type |
| CGlobalStringAtomTable | Global string atom table |
| CDebugInfo | Debug functionality: DebugInfo struct |
| CHashTable | Organizes key/value pairs by a hash code |
| CIterator | |
| CKeyValuePair | Key/Value pair objects are used by most assiociative container classes, like Dictionary or HashTable |
| CList | Implements a doubly linked list |
| CIterator | List iterator |
| CNode | Node in the list |
| CLocalStringAtomTable | Implements a thread-local string atom table which is used as a cache to prevent excessive locking when creating string atoms |
| COccupancyQuadTree | |
| CNode | |
| CPinnedArray | |
| CPriorityArray | |
| CElement | Element class |
| CQuadTree | |
| CNode | Node in quad tree |
| CQueue | Nebula's queue class (a FIFO container) |
| CRandom | |
| CRandomNumberTable | A table-based random-number generator |
| CRandomUnion | |
| CRingBuffer | A ring buffer stores up to a maximum number of elements in a circular fashion |
| CRound | |
| CRunLengthCodec | A simple byte-based runlength encoder/decoder |
| CSet | A collection of unique values with quick lookup |
| CSimpleTree | A simple tree class which stores its nodes in Util::Arrays |
| CNode | Public node class |
| CSparseTable | A 2D sparse table where many entries may be redundant and support for multiple entries per cell |
| CTableEntry | Table entry in the sparse table |
| CStack | Nebula's stack class (a FILO container) |
| CString | Nebula's universal string class |
| CStringAtom | A StringAtom |
| CStringAtomTableBase | This implements the base class for thread-local and global string atom table classes |
| CStaticString | Static string class for sorting the array |
| CStringBuffer | Global string buffer for the StringAtom system |
| CStringInterop | |
| CTrivialArray | Array class based on Util::Array for trivial and POD types that avoids any per element copying and constructor/destructor calls |
| CVariant | An "any type" variable |
| NVegetation | The vegetation context handles rendering of grass, trees and other types of vegetation |
| C[struct].vegetationState | |
| CCombinedMeshVertex | |
| CGrassVertex | |
| CVegetationBiomeId | |
| CVegetationContext | |
| CVegetationGrassSetup | |
| CVegetationMeshSetup | |
| CVegetationSetupSettings | |
| NVisibility | Implements a resource loader for models |
| CBoxSystem | |
| CBoxSystemLoadInfo | |
| CBruteforceSystem | |
| CBruteforceSystemLoadInfo | |
| CObservableContext | |
| CObserverContext | |
| CVisibilityModelCommand | |
| CVisibilityDrawCommand | |
| CVisibilityBatchCommand | |
| CVisibilityDrawList | |
| COctreeSystem | |
| COctreeSystemLoadInfo | |
| CPortalSystem | |
| CPortalSystemLoadInfo | |
| CQuadtreeSystem | |
| CQuadtreeSystemLoadInfo | |
| CVisibilityContainer | |
| CVisibilitySystem | |
| CObserver | |
| CEntity | |
| NVulkan | Vulkan implementation of GPU acceleration structure |
| CBindInfo | |
| CBufferMapping | |
| CBufferSparsePageTable | |
| CCommandBufferPools | |
| CDerivativeLayout | |
| CDescriptorSetBinding | |
| CGeometrySetup | |
| CGraphicsDeviceState | |
| CConstantsRingBuffer | |
| CFlushedRanges | |
| CSparseImageBind | |
| CSparseBufferBind | |
| CPendingDeletes | |
| CPendingMarkers | |
| CQueries | |
| CInstanceSetup | |
| CPipeline | |
| CQueryBundle | |
| CQueryChunk | |
| CQueryState | |
| CRenderPassShaderInterface | |
| CSceneSetup | |
| CScissorBundle | |
| CTextureSparsePageTable | |
| CVertexLayoutVkBindInfo | |
| CViewportBundle | |
| CVkBarrierInfo | |
| CVkBufferLoadInfo | |
| CVkBufferMapInfo | |
| CVkBufferRuntimeInfo | |
| CVkCommandBufferThread | |
| CVkCommandBufferBeginCommand | |
| CVkCommandBufferResetCommand | |
| CVkCommandBufferEndCommand | |
| CVkGfxPipelineBindCommand | |
| CVkComputePipelineBindCommand | |
| CVkVertexBufferCommand | |
| CVkIndexBufferCommand | |
| CVkDrawCommand | |
| CVkIndirectDrawCommand | |
| CVkIndirectIndexedDrawCommand | |
| CVkDispatchCommand | |
| CVkDescriptorsCommand | |
| CVkPushConstantsCommand | |
| CVkViewportCommand | |
| CVkViewportArrayCommand | |
| CVkScissorRectCommand | |
| CVkScissorRectArrayCommand | |
| CVkStencilRefCommand | |
| CVkStencilReadMaskCommand | |
| CVkStencilWriteMaskCommand | |
| CVkUpdateBufferCommand | |
| CVkSetEventCommand | |
| CVkResetEventCommand | |
| CVkWaitForEventCommand | |
| CVkBarrierCommand | |
| CVkWriteTimestampCommand | |
| CVkBeginQueryCommand | |
| CVkEndQueryCommand | |
| CVkBeginMarkerCommand | |
| CVkEndMarkerCommand | |
| CVkInsertMarkerCommand | |
| CVkDeferredCommand | |
| CDelegate | |
| C[union].__unnamed0__ | |
| C[struct].__unnamed0__.cmdbufferfree | |
| C[struct].__unnamed0__.memory | |
| C[struct].__unnamed0__.buffer | |
| C[struct].__unnamed0__.image | |
| C[struct].__unnamed0__.bufferUpd | |
| C[struct].__unnamed0__.imageUpd | |
| C[struct].__unnamed0__.pipelineDestroy | |
| C[struct].__unnamed0__.imgBarrier | |
| C[struct].__unnamed0__.imgColorClear | |
| C[struct].__unnamed0__.imgDepthStencilClear | |
| C[struct].__unnamed0__.imgOwnerChange | |
| C[struct].__unnamed0__.descSetBind | |
| CVkDepthStencilTarget | |
| CVkDisplayDevice | |
| CVkEventInfo | |
| CVkFenceInfo | |
| CVkInstanceRenderer | |
| CVkInstanceServer | |
| CVkPassLoadInfo | |
| CVkPassRuntimeInfo | |
| CVkPipelineBundle | |
| CVkPipelineDatabase | |
| CBaseNode | |
| CTier1Node | |
| CTier2Node | |
| CTier3Node | |
| CTier4Node | |
| CVkProgramReflectionInfo | |
| CVkReflectionInfo | |
| CUniformBuffer | |
| CVariable | |
| CVkScheduler | |
| CVkShaderProgramRuntimeInfo | |
| CVkShaderProgramSetupInfo | |
| CVkShaderRuntimeInfo | |
| CVkShaderServer | |
| C_PendingView | |
| C_PendingViewDelete | |
| CVkShaderSetupInfo | |
| CVkShapeRenderer | |
| CIndexedDraws | |
| CUnindexedDraws | |
| CVkSubContextHandler | |
| CTimelineSubmission | |
| CTimelineSubmission2 | |
| CSubmissionList | |
| CSparseBindSubmission | |
| CVkTextRenderer | |
| CTextElementVertex | |
| CVkTextureLoadInfo | |
| CVkTextureMappingInfo | |
| CVkTextureRuntimeInfo | |
| CVkTextureSwapInfo | |
| CVkTextureViewLoadInfo | |
| CVkTextureViewRuntimeInfo | |
| CVkTypes | |
| CVkBlockDimensions | |
| CWriteInfo | |
| C[union].__unnamed0__ | |
| NWin32 | [TODO: Describe Win32 subsystem] |
| CParentWindow | |
| CSysFunc | Provides Win32 specific helper functions |
| CWin32CalendarTime | Win implementation of CalendarTime |
| CWin32ConsoleHandler | The default console handler for Win32, puts normal messages to the debug output channel, and error messages into a message box |
| CWin32Cpu | CPU related definitions for the Win32 platform |
| CWin32CriticalSection | Win32-implementation of critical section |
| CWin32DisplayDevice | Win32 implementation of DisplayDevice class |
| CWin32Environment | Provides read-access to environment variables |
| CWin32Event | Win32 implementation of an event synchronization object |
| CWin32FileTime | Implements a Win32-specific file-access time stamp |
| CWin32FSWrapper | Internal filesystem wrapper for Win32 |
| CWin32Guid | Win32 implementation of the Util::Guid class |
| CWin32Heap | Win32 implementation of the class Memory::Heap |
| CWin32IpAddress | Represents an IP address, consisting of a IPv4 host address and a port number |
| CWin32Library | Load and handle an external DLL |
| CWin32MemoryPool | A simple thread-safe memory pool |
| CWin32MiniDump | Win32 implementation of MiniDump |
| CWin32ReadWriteLock | |
| CWin32Registry | A simple wrapper class to access the Win32 registry |
| CWin32Socket | A lowlevel socket wrapper class |
| CWin32StackTrace | |
| CWin32StringConverter | Convert between UTF-8 and 16-bit wide strings |
| CWin32SystemInfo | Provide information about the system we're running on |
| CWin32Thread | Win32 implementation of thread class |
| CWin32ThreadBarrier | Block until all thread have arrived at the barrier |
| CWin32Timer | Win32 implementation of the Time::Timer class |
| CAccessMode | |
| CAnimResource | A AnimResource is a collection of related animation clips (for instance all animation clips of a character) |
| 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 |
| CBarrier | Implements the 2 macros ReadWriteBarrier and MemoryBarrier |
| CBindlessRegistry | Handles binding of bindless resources |
| CBufferSetup | Types used for buffers, how they are created and their intended usage |
| CBvh | A generic bounding volume (AABB) hierarchy |
| CByteOrder | (C) 2007 Radon Labs GmbH (C) 2013-2018 Individual contributors, see AUTHORS file |
| 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 |
| CCameraSettings | Helper class for handling camera projection and related settings |
| CCharacterMaterialSkinNode | A model node that handles materials for characters |
| CCharacterNode | Wraps a Character object into a ModelNode for rendering |
| Ccompletion_t | |
| Ccore | Basic type definitions for Nebula |
| CCriticalSection | Critical section objects are used to protect a portion of code from parallel execution |
| CDarwinBarrier | Implements the 2 macros ReadWriteBarrier and MemoryBarrier |
| CDisplayDevice | A DisplayDevice object represents the display where the RenderDevice presents the rendered frame |
| CEnvironment | Provides read-access to environment variables |
| CEvent | |
| CFenceCreateInfo | A fence is a CPU-GPU sync object, used to let the CPU wait for the GPU to finish some work |
| CFileDialog | Wrapper around NFD for showing file dialogs |
| CFileTime | Defines a file-access timestamp |
| CFileWatcher | Linux implementation of filewatcher |
| CFileWatcher | Win32 implementation of filewatcher |
| CFilterset | Used to query a database |
| CFrameBuilder | |
| 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 |
| CGLFWDisplayDevice | GLFW based OpenGL implementation of DisplayDevice class |
| CGLFWInputServer | Glfw-specific InputServer (provides a default Keyboard and Mouse) |
| CGlobalConstants | Management place for global constants, such as those in the tick/frame groups |
| CGuid | Implements a GUID |
| CHash | Generic hash function class based on murmurhash3 |
| CHeap | Implements a private heap |
| CHttpClient | Use a HTTP client to send HTTP requests to a HTTP server, and receive and decode HTTP responses |
| CIGFD_FileDialog_Config | |
| CIGFD_Selection | |
| CIGFD_Selection_Pair | |
| CIm3dContext | Nebula renderer for Im3d gizmos |
| CImguiRenderer | Nebula renderer for the IMGUI dynamic UI library |
| CImguiRTPlugin | Use this class to integrate Imgui with the Nebula rendering loop |
| 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 |
| CInterface | Implements the asynchronous interface to the IO subsystem |
| CInterlocked | Provide simple atomic operations on memory variables |
| CIpAddress | Represents an IP address, consisting of a IPv4 host address and a port number |
| CKeyboard | An input handler which represents a keyboard for polling |
| CLibrary | Use to load dynamic libraries and their addresses |
| CLinuxThreadId | A thread id uniquely identifies a thread within the process |
| CListExt | |
| CMemoryPool | A simple thread-safe memory pool |
| CMiniDump | Support for generating mini dumps |
| CNebulaSettings | Platform independent way for storing persistent settings Will use registry in windows and config files on other platforms |
| CNvx2StreamReader | A stream reader which reads legacy nvx2 binary mesh files |
| CNvx3StreamReader | A stream reader which reads legacy nvx3 binary mesh files |
| COSXThreadId | A thread id uniquely identifies a thread within the process |
| CParticleRenderInfo | ParticleRenderInfo objects are returned by the ParticleRenderer singleton when a visible particle system is attached |
| CParticleSystemMaterialNode | The ParticleSystemNode wraps a ParticleSystem object into a ModelNode for rendering using materials |
| CPass | A pass describe a set of textures used for rendering |
| CPhysicsInterface | |
| CPosixBarrier | Implements the 2 macros ReadWriteBarrier and MemoryBarrier |
| CPosixThreadId | A thread id uniquely identifies a thread within the process |
| CPQuatFeedbackLoop | A specialized proportional feedback loop for rotations, using a quaternion representation |
| CPQuatFeedbackLoop | |
| CPriorityArray | A fixed size priority array |
| CProcess | Launch an external application |
| CPtr | Nebula's smart pointer class which manages the life time of RefCounted objects |
| CQuadTree | A simple quad tree |
| CQuatX | |
| CRound | Helper class for rounding up integer values to 2^N values |
| CShaderServer | The ShaderServer object loads the available shaders and can instantiate shaders for usage |
| CShapeRenderer | Render shapes for debug visualizations |
| CSingleton | Implements a system specific Singleton |
| CSocket | Platform independent wrapper class for the Sockets API |
| CSqlite3FilterSet | SQLite3 implement of Db2::FilterSet |
| CStackTrace | Helper class for generating stack traces |
| CStackWalkerToString | |
| CStreamAnimationLoader | Initialize a CoreAnimation::AnimResource from the content of a stream |
| CStreamShaderLoader | Resource loader to setup a Shader object from a stream |
| CStreamTextureCache | Resource loader for loading texture data from a Nebula stream |
| CSysFunc | Wrap some platform specific low-level functions |
| CSystemInfo | Provides information about the host system |
| CTcpClient | See StdTcpClient for details |
| CTcpClientConnection | See StdTcpClientConnection for details! |
| CTcpServer | Front-end wrapper class for StdTcpServer, see StdTcpServer for details! |
| CTextRenderer | A simple text renderer for drawing text on screen |
| CThread | |
| CThreadBarrier | Block until all thread have arrived at the barrier |
| CThreadLocalMiniHeap | |
| CTimer | A timer object is the most basic object for time measurement |
| CTiXmlAttribute | An attribute is a name-value pair |
| CTiXmlAttributeSet | |
| CTiXmlBase | TiXmlBase is a base class for every class in TinyXml |
| CStringToBuffer | |
| CEntity | |
| CTiXmlComment | An XML comment |
| CTiXmlCursor | |
| 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 |
| CTiXmlHandle | A TiXmlHandle is a class that wraps a node pointer with null checks; this is an incredibly useful thing |
| CTiXmlNode | The parent class for everything in the Document Object Model |
| CTiXmlOutStream | |
| CTiXmlParsingData | |
| CTiXmlString | |
| CRep | |
| CTiXmlText | XML text |
| CTiXmlUnknown | Any tag that tinyXml doesn't recognize is saved as an unknown |
| CVertexLayoutBase | Base class for platform-specific vertex component subclasses |
| CView | A view describes a camera which can observe a Stage |
| CWeakPtr | A smart pointer which does not change the reference count of the target object |
| CWin32Barrier | Implements the 2 macros ReadWriteBarrier and MemoryBarrier |
| CWin32Interlocked | Provides simple atomic operations on shared variables |
| CWin32Stacktrace | Win32 implementation of stacktrace |
| CWinThreadId | A thread id uniquely identifies a thread within the process |