| ►Nkanzi | |
| ►Nandroid_ws | |
| CDefaultAndroidWSEGLGraphicsOutput | Class representing a default Android window surface EGL graphics output |
| CDefaultAndroidWSEGLGraphicsOutputProperties | Struct representing the default Android window surface EGL graphics output properties |
| ►Nemscripten | |
| CDefaultEmscriptenGraphicsOutput | Class representing a default Emscripten graphics output |
| CDefaultEmscriptenGraphicsOutputProperties | The structure that represents the default emscripten graphics output properties |
| ►Nevdev | |
| CCursorData | Struct representing cursor data |
| CEvdevInput | Class representing evdev input |
| CTouchInputDeviceData | Struct representing touch input device data |
| ►Ngfx | |
| ►Nreflection | |
| CAccelerationStructure | Acceleration structure reflection information |
| CAttribute | Reflection entry for a stage input or output attribute |
| CBindingBlock | Describes a binding block which corresponds to a resource set |
| CBuffer | Buffer reflection information |
| CImage | Image reflection information |
| CInterfaceBlock | Describes an interface block that can be a uniform buffer object or push constant object |
| CInterfaceBlockHasher | Hasher for InterfaceBlock, combines the name, byte offset, and type information of each member to produce a hash that reflects the full layout of the block |
| CMember | Describes a uniform member |
| CReflectionInfo | Top-level structure that contains the reflection information for a shader stage or program |
| CSampler | Sampler reflection information |
| CTypeInfo | Contains a description of a shader value |
| CUniformBlockBuilder | A helper class to build uniform blocks based on reflection information |
| CAbstractBackend | Defines of a graphics library backend |
| CAddTopLevelAccelerationStructureInstanceCommand | Adds top level acceleration structure instance |
| CArrayType | |
| CAttachmentDescriptionSet | Describes a set of attachment descriptions |
| CBackendInformation | Describes the backend implementation |
| CBackendLayer | Base class for a backend layer |
| CBaseCommand | The base class for all graphics commands |
| CBaseCreateInfo | The base class for all create info structures |
| CBeginBuildBottomLevelAccelerationStructureCommand | Begins build bottom level acceleration structure |
| CBeginBuildTopLevelAccelerationStructureCommand | Begins build top level acceleration structure |
| CBeginComputePipelineCommand | Begins a compute pipeline in the command stream |
| CBeginDebugScopeCommand | Pushes a named debug group onto the backend's debug-label stack |
| CBeginRenderPassCommand | Begins a render pass in the command stream |
| CBeginRenderPipelineCommand | Begins a render pipeline in the command stream |
| CBindComputeResourceSetCommand | Binds the resource sets within the current compute pipeline |
| CBindRenderResourceSetCommand | Binds the resource sets within the current render pipeline |
| CBindVertexInputCommand | Binds the vertex buffer bindings within the current render pipeline |
| ►CBlendStateCreateInfo | Creation information for a blend state |
| CRenderTargetBlendInfo | Describes the per-attachment blend information |
| CBottomLevelAccelerationStructureCreateInfo | Creation information for a bottom level acceleration structure |
| CBox | |
| CBufferCreateInfo | Creation information for a buffer |
| CBuildBottomLevelAccelerationStructureCommand | Builds bottom level acceleration structure |
| CByteRange | Defines a range of bytes |
| CCapabilityEmulator | |
| CClearCommand | Clears viewport |
| CColorAttachmentDescription | Describes the color attachment behavior for a render pass |
| CCommandBufferCreateInfo | Creation information for a command buffer |
| CComputePipelineCreateInfo | Creation information for a compute pipeline |
| CComputeResourceSetCreateInfo | Creation information for a set of compute resources used by a shader program |
| CConstantDataCommand | Sets current constant data in a render pipeline |
| CCopyBufferCommand | Copies a region of a source buffer to a destination buffer |
| CCopyBufferToImageCommand | Copies a source buffer to a destination image |
| CCopyImageCommand | Copies a subresource of a source image to a destination image |
| CCopyImageToBufferCommand | Copies a source image to a destination buffer |
| CCopySurfaceToBufferCommand | Copies an on-screen surface to a destination buffer |
| CDebugInformation | Interface to access Kanzi graphics debug information, such as object names |
| CDefaultHandleGuardT | Helper struct to construct a default handle of any type |
| CDepthAttachmentDescription | Describes the depth attachment behavior for a render pass |
| ►CDepthStencilStateCreateInfo | Creation information for a depth stencil state |
| CStencilOperationState | Describes a stencil operation state |
| CDispatchCommand | Dispatches a compute operation in a compute pipeline |
| CDispatchIndirectCommand | Dispatches an indirect compute operation in a compute pipeline |
| CDispatchIndirectData | DispatchIndirect data buffer format |
| CDrawCommand | Issues a draw command in a render pipeline |
| CDrawIndirectCommand | Issues an indirect draw command in a render pipeline |
| CDrawIndirectData | DrawIndirect data buffer format |
| CDrawIndirectIndexedData | DrawIndirect indexed data buffer format |
| CEndBuildBottomLevelAccelerationStructureCommand | Ends build bottom level acceleration structure |
| CEndBuildTopLevelAccelerationStructureCommand | Ends build top level acceleration structure |
| CEndComputePipelineCommand | Ends a compute pipeline in the command stream |
| CEndDebugScopeCommand | Pops the most recent debug group from the backend's debug-label stack |
| CEndRenderPassCommand | Ends a render pass in the command stream |
| CEndRenderPipelineCommand | Ends a render pipeline in the command stream |
| ►CFrameBufferCreateInfo | Creation information for a frame buffer |
| CAttachment | Attachment definition |
| CGenerateMipmapsCommand | Generates mipmaps for an image |
| CGpuFenceCreateInfo | Creation information for a GPU fence |
| CGPUSceneCreateInfo | Creation information for a GPU scene |
| CHandleGuard | The HandleGuard class provides a reference counted reference to a graphics handle |
| CHandleObject | Base class for internal backend objects that are referred to by Handles |
| CHardwareCapabilitiesProfile | Hardware Capabilities Profile represents |
| ►CImageCreateInfo | Creation information for an image |
| CSliceInitialData | Description of a single slice of initial data |
| CImageSubresource | The image subresource describes a subset of a full resource |
| CInitializationInfo | Graphics library initialization information |
| CInvalidHandleGuardT | Helper struct to construct an invalid handle of any type |
| CIssueQueryCommand | Issues a GPU query |
| CMatrix | |
| CMaxBoxT | |
| CMaxVectorT | |
| CNativeSurfaceHandle | Information necessary for native surfaces such as windows |
| CNativeTextureHandle | Describes the native handle information |
| CObjectStatus | Object status and message |
| COpenGLInitializationInfo | Defines the initialization parameters for the OpenGL backend |
| CPresentCommand | Presents the surface frame buffer |
| CQueryPoolCreateInfo | Creation information for a GPU query pool |
| CRasterStateCreateInfo | Creation information for a raster state |
| CRenderPassCreateInfo | Creation information for a render pass |
| CRenderPipelineCreateInfo | Creation information for a render pipeline |
| CRenderResourceSetCreateInfo | Creation information for a set of render resources used by a shader program |
| CResetQueryPoolCommand | Reset a GPU query pool |
| CResolveMultisampleImageCommand | Resolves a multisampled image |
| ►CResourceSetCreateInfo | Creation information for a resource set |
| CAccelerationStructureView | Describes an acceleration structure view |
| CBufferView | Describes a buffer view. May be uniform or storage buffer |
| CImageView | Describes an image view |
| CSampler | Describes a sampler |
| CTexelBufferView | Describes a texel or image buffer view |
| CSamplerCreateInfo | Creation information for a sampler |
| CSetLineWidthCommand | Sets the line width for current render pipeline |
| CSetScissorCommand | Sets the scissor coordinates |
| CSetUniformOffsetCommand | Sets a Uniform Offset that will take effect with the next BindRenderResourceSetCommand or BindRenderResourceSetCommand |
| CSetViewportCommand | Sets the viewport coordinates |
| CShaderCreateInfo | Creation information for a shader |
| CSignalGpuFenceCommand | Signals a GPU fence |
| ►CStatistics | Interface to access Kanzi graphics statistics, such as object and command counts |
| CCommandStats | Command-related statistics since last report |
| CObjectStats | Defines the statistics exposed for an object type |
| CResults | Contains a full Statistics report |
| CSubroutineCommand | Causes the command processing to transfer execution to the subroutine command buffer |
| CSwizzleMask | Swizzle options for each channel of a format |
| CTopLevelAccelerationStructureCreateInfo | Creation information for a top level acceleration structure |
| CUpdateGPUSceneCommand | Updates GPU scene |
| CVector | |
| CVertexAttribute | Describes an individual vertex attribute, typically part of a vertex binding |
| CVertexBinding | Describes a vertex buffer binding |
| CVertexBufferBinding | Describes a Vertex Buffer Binding |
| CVertexInputStateCreateInfo | Creation information for a vertex input state |
| CVulkanInitializationInfo | Defines the initialization parameters for the Vulkan backend |
| ►Ninterop | |
| CActionDirector | |
| CActivityCodeBehindDirector | |
| CActivityConceptEnums | |
| CBlurEffect2DEnums | |
| CCallbackBindingProcessorDirector | |
| CCameraEnums | |
| ►CCodeBehindDirector | |
| CCommandHandlerDirector | |
| CConditionDirector | |
| CConstraintsEnums | |
| CContainerWrapper | |
| CDataContextModifiedSubscriptionDirector | |
| CDataObjectListDirector | |
| CDataSourceDirector | |
| CDockLayoutConceptEnums | |
| CDrawObjectsRenderPassEnums | |
| CEffectStack2DEnums | |
| CExclusiveActivityHostConceptEnums | |
| CFlowLayoutConceptEnums | |
| CForwardingActionDirector | |
| CGridLayoutConceptEnums | |
| CGridListBoxConceptEnums | |
| CLanguageDirector | |
| CLanguagePlugin | |
| CListBoxItemGenerator2DDirector | |
| CListBoxItemGenerator3DDirector | |
| CMaskEffect2DEnums | |
| CMatrix4x4Enums | |
| CMessageSubscriptionDirector | |
| CMetaclassDirector | |
| CMetaclassReleaseVisitor | |
| CNode2DDirector | |
| CNode2DEnums | |
| CNode3DDirector | |
| CNodeComponentDirector | |
| CNodeEnums | |
| COutlineEffect2DEnums | |
| ►CPageTransitionCollectionEnums | |
| CTransition | |
| CParallelActivityHostConceptEnums | |
| CPipelineStateConceptEnums | |
| CPluginDirector | |
| CPluginHandlerDirector | |
| CPropertyTargetEasingInterpolatorEnums | |
| CPropertyTargetEasingTimelineEnums | |
| CResourceAcquireTaskDirector | |
| CResourceLoadTaskDirector | |
| ►CResourceProtocolDirector | |
| CResult | |
| CResourceReloadProtocolDirector | |
| CScreenEnums | |
| CScrollViewConceptEnums | |
| CShadowEffect2DEnums | |
| CStaleObjectException | Exception which is thrown when a wrapper no longer points to a valid object |
| CTaskDirector | |
| CTaskDispatcherTaskDirector | |
| CTextBoxConceptEnums | |
| CTextFormatEnums | |
| CTextureCreateInfo | Struct which contains all the parameters that are needed for texture creation |
| ►CTextureEnums | |
| CCreateInfo | |
| CTimerTaskDirector | |
| CTrajectoryEnums | |
| CTriggerDirector | |
| CTypedIteratorWrapper | |
| CUnwrapInPtr | |
| CUnwrapOutPtr | |
| CValueAccumulatorBaseEnums | |
| ►Nios | |
| CDefaultIosGraphicsOutput | Class that represents the default iOS graphics output |
| ►Nmacos | |
| CDefaultMacosGraphicsOutput | Class that represents the default MacOS graphics output |
| CDefaultMacosGraphicsOutputProperties | Default properties to use when creating DefaultMacosGraphicsOutput |
| ►Nohos | |
| CDefaultOhosEGLGraphicsOutput | Class representing a default OpenHarmony OS 4.1 EGL graphics output |
| CDefaultOhosEGLGraphicsOutputProperties | Struct representing the default OpenHarmony OS 4.1 EGL graphics output properties |
| CHilogLogger | Class representing the backend that forwards Kanzi logs to OHOS |
| ►Nplatform | |
| CAbstractWindowSurface | Base class for surface-specific data |
| CAndroidPlatformContext | Android platform context class |
| CApiBackendBasicInfo | Stores basic information about API backend |
| CApiBackendVersion | Represents API backend version |
| CEglEmscriptenGraphicsContext | EGL implementation of GlGraphicsContext for Emscripten |
| ►CEglGraphicsContext | EGL implementation of GlGraphicsContext |
| CContextData | Context-specific data |
| CEglExtensionFlags | Represents support for EGL extensions |
| CEglInfo | EGL information |
| CSurfaceData | Surface-specific data |
| CThreadData | Thread-specific data |
| CEglOhosGraphicsContext | EGL implementation of GlGraphicsContext for OpenHarmony OS |
| CEglQnxStreamsGraphicsContext | EGL implementation of GlGraphicsContext for QNX streams |
| CEglWaylandGraphicsContext | EGL implementation of GlGraphicsContext for Wayland |
| CEglX11GraphicsContext | EGL implementation of GlGraphicsContext for X11 |
| CEmscriptenPlatformContext | Emscripten platform context class |
| CGLFunctionPointers | |
| ►CGlGraphicsContext | The OpenGL context API interface that is used by the OpenGL backend to interact with the platform |
| CInitializationInfo | The initialization parameters for the OpenGL context API |
| CSurfaceContextHandle | The SurfaceContext handle is used to identify an OpenGL context that is used by the rendering thread |
| CSurfaceHandle | The Surface handle is used to identify a platform surface that can be used as a target for OpenGL rendering |
| CThreadContextHandle | The ThreadContext handle is used to identify an OpenGL context that is used by user threads to perform OpenGL operations on behalf of the rendering thread |
| CGlxGraphicsContext | GLX implementation of GlGraphicsContext |
| CMacosPlatformContext | MacOS platform context class |
| CPlatformContext | Kanzi platform context interface definition |
| CQnxPlatformContext | QNX platform context class |
| CQnxStreamsSurface | Surface abstraction for QNX streams |
| CStandardSurface | Standard surface abstraction |
| CStubPlatformContext | Stub platform context class |
| CSurfaceBits | Describes the bit representation of a surface buffer |
| CSurfaceProperties | Describes the properties of a surface |
| CWaylandPlatformContext | Wayland platform context class |
| CWglGraphicsContext | WGL implementation of GlGraphicsContext |
| CWin32PlatformContext | Win32 platform context class |
| CX11PlatformContext | X11 platform context class |
| ►Nposix | |
| CPosixDynamicLibrary | POSIX dynamic library |
| ►Nqnx | |
| CDefaultQnxEGLGraphicsOutput | Class representing a default QNX EGL graphics output |
| CDefaultQnxEGLGraphicsOutputProperties | The structure that represents the default QNX EGL graphics output properties |
| CDefaultQnxInputEventContext | Structure representing the default context for an async input event |
| CDefaultQnxInputEventThread | Structure representing the default QNX input event thread |
| CDefaultQnxPulseHandler | |
| CQnxBuffer | Wrapper for a QNX buffer class |
| CQnxBufferMethods | Class representing QNX buffer methods |
| CQnxChannelID | Class representing QNX communication channel ID |
| CQnxConnectionID | Class representing QNX connection ID |
| CQnxContext | Wrapper for a QNX context class |
| CQnxContextMethods | Class representing QNX context methods |
| CQnxDisplay | Wrapper for a QNX display class |
| CQnxDisplayMethods | Class representing QNX display methods |
| CQnxEGLPBufferGraphicsOutputProperties | Properties required to construct a QnxEGLPBufferGraphicsOutput |
| CQnxEGLWindow | Class representing a QNX EGL window |
| CQnxEvent | Wrapper for a QNX event class |
| CQnxEventMethods | Class representing QNX event methods |
| CQnxNativeWindowHandles | Represents native handles that can be used by this graphics output |
| CQnxPixmap | Wrapper for a QNX pixmap class |
| CQnxPixmapMethods | Class representing QNX pixmap methods |
| CQnxPropertyHost | An interface to access and set QNX properties |
| CQnxSigEvent | Class representing QNX sig event |
| CQnxStream | Wrapper for a QNX stream class |
| CQnxStreamEGLGraphicsOutput | Class representing a EGL graphics output that renders into a QNX stream |
| CQnxStreamEGLGraphicsOutputProperties | The structure that represents the QNX Stream EGL graphics output properties |
| CQnxStreamFramebufferHandle | Shared data between graphics output and GL context API for QNX streams |
| CQnxStreamMethods | Class representing QNX stream methods |
| CQnxWindow | Wrapper for a QNX window class |
| CQnxWindowMethods | Class representing QNX window methods |
| CQnxWindowProperties | Represents properties that are used to construct QnxWindow |
| CTouchPoint | Structure representing an individual touch point (cursor) |
| ►Nschema | |
| CAttributeMessageBuilder | |
| CBinaryProgramCombinedMessageBuilder | |
| CBinaryProgramSeparateMessageBuilder | |
| CBinaryProgramStageMessageBuilder | |
| CBinaryProgramUnionTraits | |
| CBinaryProgramUnionTraits< kanzi::schema::BinaryProgramCombinedMessage > | |
| CBinaryProgramUnionTraits< kanzi::schema::BinaryProgramSeparateMessage > | |
| CBinaryShaderMessageBuilder | |
| CBindingDataSourceValueSourceMessageBuilder | |
| CBindingMessageBuilder | |
| CBindingModeUnionTraits | |
| CBindingModeUnionTraits< kanzi::schema::OneWayBindingMessage > | |
| CBindingModeUnionTraits< kanzi::schema::ToSourceBindingMessage > | |
| CBindingModeUnionTraits< kanzi::schema::TwoWayBindingMessage > | |
| CBindingObjectPropertyValueSourceMessageBuilder | |
| CBindingOperationAnimationBuilder | |
| CBindingOperationRangeBuilder | |
| CBindingOperationUnionTraits | |
| CBindingOperationUnionTraits< kanzi::schema::BindingOperationAnimation > | |
| CBindingOperationUnionTraits< kanzi::schema::BindingOperationInstruction > | |
| CBindingOperationUnionTraits< kanzi::schema::BindingOperationRange > | |
| CBindingOperationUnionTraits< kanzi::schema::BindingOperationRangeAccumulate > | |
| CBindingRenderPropertyValueSourceMessageBuilder | |
| CBindingTargetModifierMessageBuilder | |
| CBindingTargetRenderValueMessageBuilder | |
| CBindingTargetUnionTraits | |
| CBindingTargetUnionTraits< kanzi::schema::BindingTargetModifierMessage > | |
| CBindingTargetUnionTraits< kanzi::schema::BindingTargetRenderValueMessage > | |
| CBindingTargetUnionTraits< kanzi::schema::BindingTargetValueSourceMessage > | |
| CBindingTargetUnionTraits< kanzi::schema::BindingTargetVariableMessage > | |
| CBindingTargetValueSourceMessageBuilder | |
| CBindingTargetVariableMessageBuilder | |
| CBindingValueSourceUnionTraits | |
| CBindingValueSourceUnionTraits< kanzi::schema::BindingDataSourceValueSourceMessage > | |
| CBindingValueSourceUnionTraits< kanzi::schema::BindingObjectPropertyValueSourceMessage > | |
| CBindingValueSourceUnionTraits< kanzi::schema::BindingRenderPropertyValueSourceMessage > | |
| CBindingValueSourceUnionTraits< kanzi::schema::BindingVariableValueSourceMessage > | |
| CBindingVariableValueSourceMessageBuilder | |
| CFLATBUFFERS_FINAL_CLASS | Value source binding target |
| CImage2DMessageBuilder | |
| CImageMessageBuilder | |
| CImageMessageUnionTraits | |
| CImageMessageUnionTraits< kanzi::schema::Image2DMessage > | |
| CImageMessageUnionTraits< kanzi::schema::ImageRawMessage > | |
| CImageMessageUnionTraits< kanzi::schema::MipmapImageMessage > | |
| CImageRawMessageBuilder | |
| CMaterialTypeMessageBuilder | |
| CMipmapImageMessageBuilder | |
| COneWayBindingMessageBuilder | |
| CReflectionAccelerationStructureMessageBuilder | |
| CReflectionAttributeMessageBuilder | |
| CReflectionBindingBlockMessageBuilder | |
| CReflectionBufferMessageBuilder | |
| CReflectionImageMessageBuilder | |
| CReflectionInfoMessageBuilder | |
| CReflectionInterfaceBlockMemberMessageBuilder | |
| CReflectionInterfaceBlockMessageBuilder | |
| CReflectionSamplerMessageBuilder | |
| CShaderSetMessageBuilder | |
| CShaderSourceMessageBuilder | |
| CTexture2DMessageBuilder | |
| CTexture3DMessageBuilder | |
| CTextureCubemapMessageBuilder | |
| CTextureCubemapRenderTargetMessageBuilder | |
| CTextureInternalMessageTraits | |
| CTextureInternalMessageTraits< kanzi::schema::Texture2DMessage > | |
| CTextureInternalMessageTraits< kanzi::schema::Texture3DMessage > | |
| CTextureInternalMessageTraits< kanzi::schema::TextureCubemapMessage > | |
| CTextureInternalMessageTraits< kanzi::schema::TextureCubemapRenderTargetMessage > | |
| CTextureInternalMessageTraits< kanzi::schema::TextureNativeImageMessage > | |
| CTextureInternalMessageTraits< kanzi::schema::TextureRenderTargetMessage > | |
| CTextureMessageBuilder | |
| CTextureNativeImageMessageBuilder | |
| CTextureRenderTargetMessageBuilder | |
| CToSourceBindingMessageBuilder | |
| CTwoWayBindingMessageBuilder | |
| CUniformMessageBuilder | |
| CUniformNamePropertyTypeMessageBuilder | |
| CUniformNameRenderValueMessageBuilder | |
| CUniformNameUnionTraits | |
| CUniformNameUnionTraits< kanzi::schema::UniformNamePropertyTypeMessage > | |
| CUniformNameUnionTraits< kanzi::schema::UniformNameRenderValueMessage > | |
| CVariantMessageBuilder | |
| CVariantValueRangeBuilder | |
| CVariantValueResourceIDBuilder | |
| CVariantValueStringBuilder | |
| CVariantValueUnionTraits | |
| CVariantValueUnionTraits< kanzi::schema::VariantValueBool > | |
| CVariantValueUnionTraits< kanzi::schema::VariantValueColor > | |
| CVariantValueUnionTraits< kanzi::schema::VariantValueFloat > | |
| CVariantValueUnionTraits< kanzi::schema::VariantValueInt > | |
| CVariantValueUnionTraits< kanzi::schema::VariantValueMatrix3x3 > | |
| CVariantValueUnionTraits< kanzi::schema::VariantValueMatrix4x4 > | |
| CVariantValueUnionTraits< kanzi::schema::VariantValuePointer > | |
| CVariantValueUnionTraits< kanzi::schema::VariantValueRange > | |
| CVariantValueUnionTraits< kanzi::schema::VariantValueResourceID > | |
| CVariantValueUnionTraits< kanzi::schema::VariantValueSRT2D > | |
| CVariantValueUnionTraits< kanzi::schema::VariantValueSRT3D > | |
| CVariantValueUnionTraits< kanzi::schema::VariantValueString > | |
| CVariantValueUnionTraits< kanzi::schema::VariantValueVector2 > | |
| CVariantValueUnionTraits< kanzi::schema::VariantValueVector3 > | |
| CVariantValueUnionTraits< kanzi::schema::VariantValueVector4 > | |
| ►Nwayland | |
| CAbstractDefaultWaylandContext | Class that represents an interface for Wayland callbacks |
| CAbstractWaylandShell | Represents a Wayland shell class interface boilerplate |
| CCoreShell | Wayland Core Shell abstraction |
| CDefaultWaylandEGLGraphicsOutput | Class that represents the default Wayland EGL graphics output |
| CDefaultWaylandEGLGraphicsOutputProperties | Default properties to use when creating DefaultWaylandEGLGraphicsOutput |
| CExitRequestEvent | Event that represents a request to close the window |
| CIviApplication | Wrapper for an IVI application class |
| CIviApplicationMethods | Class representing IVI application methods |
| CIviLayer | Represents IVI layer |
| CIviLayerProps | Collection of IviLayer properties |
| CIviLayoutManager | An abstraction class that allows to control IVI layers and surfaces |
| CIviScreen | Wrapper for a Wayland output class |
| CIviScreenMethods | Class representing Wayland output methods |
| CIviShell | Wayland IVI Shell abstraction |
| CIviSurface | Wrapper for a IVI surface class |
| CIviSurfaceMethods | Class representing IVI surface methods |
| CIviSurfaceProps | Collection of IviWmSurface properties |
| CIviWm | Wrapper for an IVI WM class |
| CIviWmMethods | Class representing IVI WM methods |
| CIviWmSurface | Represents IVI surface from WM point of view |
| CKeyboardEnterEvent | Event that represents keyboard entering the window |
| CKeyboardLeaveEvent | Event that represents keyboard leaving the window |
| CKeyEvent | Event that represents a keyboard key changing state |
| CKeyModEvent | Event that represents the current keyboard modifier state |
| CListenedWaylandOptionalHandle | Represents WaylandOptionalHandle that can accept a listener |
| CListenedWaylandOptionalHandleWrapper | OptionalHandleWrapper for a listened Wayland interface |
| CPointerAxisEvent | Event that represents mouse scroll |
| CPointerButtonEvent | Event that represents mouse button events |
| CPointerEnterEvent | Event that represents mouse entering application window |
| CPointerFrameEvent | Event that groups pointer events together |
| CPointerLeaveEvent | Event that represents mouse leaving application window |
| CPointerMotionEvent | Event that represents mouse movement |
| CTouchCancelEvent | Event that represents compositor taking over all touch points |
| CTouchDownEvent | Event that starts a touch point |
| CTouchFrameEvent | Event that groups touch events together |
| CTouchMotionEvent | Event that represents touch point movement |
| CTouchUpEvent | Event that ends a touch point |
| CWaylandCallback | Wrapper for a Wayland callback class |
| CWaylandCallbackMethods | Class representing Wayland callback methods |
| CWaylandCompositor | Wrapper for a Wayland compositor class |
| CWaylandCompositorMethods | Class representing Wayland compositor methods |
| CWaylandDisplay | Wayland display wrapper class |
| CWaylandEGLWindow | Wayland EGL window wrapper class |
| CWaylandEventVisitor | Visitor class that operates on different types of Wayland events |
| CWaylandIVIEGLGraphicsOutput | Class that represents the Wayland IVI EGL graphics output |
| CWaylandIVIEGLGraphicsOutputProperties | Default properties to use when creating WaylandIVIEGLGraphicsOutput |
| CWaylandKeyboard | Wrapper for a Wayland keyboard class |
| CWaylandKeyboardMethods | Class representing Wayland keyboard methods |
| CWaylandOptionalHandle | Represents a generic Wayland handle with managed lifetime |
| CWaylandOptionalHandleWrapper | OptionalHandleWrapper for a Wayland interface |
| CWaylandOutput | Wrapper for a Wayland output class |
| CWaylandOutputMethods | Class representing Wayland output methods |
| CWaylandPointer | Wrapper for a Wayland pointer class |
| CWaylandPointerMethods | Class representing Wayland pointer methods |
| CWaylandRegistry | Wrapper for a Wayland registry class |
| CWaylandRegistryMethods | Class representing Wayland registry methods |
| CWaylandSeat | Wrapper for a Wayland seat class |
| CWaylandSeatMethods | Represents a Wayland seat and abstracts the underlying capabilities |
| CWaylandShell | Wrapper for a Wayland shell class |
| CWaylandShellMethods | Class representing Wayland shell methods |
| CWaylandShellSurface | Wrapper for a Wayland shell surface class |
| CWaylandShellSurfaceMethods | Class representing Wayland shell_surface methods |
| CWaylandSurface | Wrapper for a Wayland surface class |
| CWaylandSurfaceMethods | Class representing Wayland surface methods |
| CWaylandTouch | Wrapper for a Wayland touch class |
| CWaylandTouchMethods | Class representing Wayland touch methods |
| CXdgPositioner | Wrapper for a Wayland XDG positioner class |
| CXdgPositionerMethods | Class representing XDG positioner methods |
| CXdgShell | Wayland Xdg Shell abstraction |
| CXdgSurface | Wrapper for a XDG surface class |
| CXdgSurfaceMethods | Class representing XDG surface methods |
| CXdgToplevel | Wrapper for a Wayland XDG toplevel class |
| CXdgToplevelMethods | Class representing XDG toplevel methods |
| CXdgWmBase | Wrapper for a Wayland XDG WM base class |
| CXdgWmBaseMethods | Class representing XDG WM base methods |
| ►Nwin32 | |
| CDefaultFiberContext | Structure that represents the default Win32 fiber context |
| CDefaultWin32WGLGraphicsOutput | Class that represents the default Win32 WGL graphics output |
| CDefaultWin32WGLGraphicsOutputProperties | Structure that represents the default Win32 WGL graphics output properties |
| CWGLContext | Class that represents the WGL context |
| CWin32DeviceContext | Class that represents the Win32 device context |
| CWin32Display | Class that represents a Win32 display |
| CWin32DynamicLibrary | Class that represents the Win32 dynamic library |
| CWin32Fiber | Class that represents the Win32 fiber |
| CWin32LParam | Structure that represents the Win32 LPARAM |
| CWin32Window | Class that represents a Win32 window |
| CWin32WindowClass | Class that represents the Win32 window class |
| CWin32WParam | Structure that represents the Win32 WPARAM |
| ►Nwindowing | |
| CPosition | Signed window position |
| CPositionF | Real window position |
| CPositionU | Unsigned window position |
| CRegion | Region for signed and unsigned size representations |
| CSize | Signed window size |
| CSizeU | Unsigned window size |
| ►Nx11 | |
| CDefaultX11EGLGraphicsOutput | Default X11 EGL graphics output |
| CDefaultX11EGLGraphicsOutputProperties | Default X11 EGL graphics output properties |
| CX11Deleter | An X11 deleter functor |
| CX11Display | An X11 display |
| CX11Window | An X11 window |
| CXClientMessageData | X client message data |
| CAbstractAnimation | Interface for abstract animations |
| CAbstractBinding | AbstractBinding is the base class for binding classes |
| CAbstractBindingRuntime | Base class for binding runtimes |
| CAbstractBindingVariableSource | Abstract interface for VariableBindingSources and VariableExpressionValueSource |
| CAbstractExpressionValueSource | Value source base for use in bindings with multiple sources |
| CAbstractExpressionValueSourceRuntime | Runtime base class for expression value sources |
| CAbstractIndexedRange | Abstract indexed range interface |
| CAbstractLogger | To implement a logger, inherit from this class |
| CAbstractMessageType | AbstractMessageType is a homogeneous message type handle to an existing message type |
| CAbstractMessageTypeDescriptor | An instance of a AbstractMessageTypeDescriptor represents a single message type in the Kanzi message system in an abstract homogeneous form |
| CAbstractNodeReference | |
| CAbstractProfiler | AbstractProfiler |
| CAbstractPropertyNotificationHandler | Abstract property notification handler |
| CAbstractPropertyType | AbstractPropertyType is a homogeneous property type handle to an existing property type |
| ►CAbstractPropertyTypeDescriptor | AbstractPropertyTypeDescriptor is used internally by the property type system to manage property types |
| CModifierEntry | |
| CModifierStorage | |
| CNotificationStorage | |
| CPropertyStorage | |
| CRawValueSourceOwner | Owner for raw value source pointers |
| CValueModifier | |
| CValueSource | |
| CValueSourceEntry | Entry pointing to value sources |
| CValueSourceOwner | Value source owner abstracts the owner pointer of a value source |
| CAbstractRange | Abstract range interface |
| CAbstractRangeIterator | Abstract range iterator interface |
| CAbstractRangeLocation | Location into a range |
| CAbstractResourceReference | |
| CAbstractValueProfiler | Abstract value profiler |
| CAction | Actions are small operations that Kanzi executes when the trigger event that contains that action occurs and the trigger conditions are met |
| CActionBase | Base abstraction class for Action classes |
| CActivity2D | An Activity is a part of application UI that is responsible for a task |
| CActivity3D | An Activity is a part of application UI that is responsible for a task |
| ►CActivityBrowserController | ActivityBrowserController is an interface class for implementing runtime data exchange between the Kanzi Studio Preview and the ActivityBrowser Kanzi Studio plugin |
| CForceTriggerMessageArguments | Message arguments for the ForceTriggerMessage |
| CNodeInfoTreeAvailableArguments | Message arguments for the NodeInfoTreeAvailableMessage |
| CActivityCodeBehind | ActivityCodeBehind is code that is associated with a particular Activity node, and has access to the properties of that Activity node |
| ►CActivityConcept | Base class for Activity classes |
| CActivityInternalMessageArguments | Class for all the internal Activity messages that do not require any message arguments |
| CActivityMessageArguments | Message arguments that hold the name of the Activity included in the message |
| CStartActivationInternalMessageArguments | Message arguments for the StartActivationInternalMessage |
| CStatusChangedInternalMessageArguments | Message arguments for internal Activity messages related to Activity status changes |
| CStatusChangedMessageArguments | Message arguments for the StatusChangedMessage |
| CActivityConceptImpl | Implementation class for ActivityConcept |
| CActivityElement | ActivityElement is the base class for all Activity and Activity Host classes |
| ►CActivityElementHistory | Encapsulates serialized data for activity elements |
| CSerializedActivityProperty | Encapsulates the serialized data for a property |
| CActivityElementImpl | ActivityElement implementation class |
| CActivityHistoryManager | ActivityHistoryManager encapsulates functionality of serialization of activities |
| ►CActivityHostConcept | Base class for Activity Host classes |
| CActivatingActivity | Class to manage storing and switching of Activity nodes |
| CActivationMessageArguments | Message arguments for ActivateActivity and DeactivateActivity messages |
| CActiveActivity | Class to manage storing and switching of Activity nodes |
| CActivityInfo | Stores information that identifies an Activity node |
| CActivityPrefabMessageArguments | Message arguments for ActivityPrefabAttachedMessage and ActivityPrefabDetachedMessage |
| CDeactivatingActivity | Class to manage storing and switching of Activity nodes |
| CRegisterActivityElementInternalMessageArguments | Message arguments for RegisterActivityElementInternal message |
| CUnregisterActivityElementInternalMessageArguments | Message arguments for UnregisterActivityElementInternal message |
| CActivityHostConceptImpl | Implementation class for ActivityHostConcept |
| CActivityHostControllerPropertyManager | Encapsulates management of activities through a controller property |
| CActivityPrefabLoader | Helper class for the Activity Host class types |
| CActivitySourceController | Encapsulates the management of data provider for Data-Driven Exclusive Activity Host |
| CActivityStatusAnimationFinishedHandler | Encapsulates dispatching of messages when an activating or a deactivating activity animation is finished |
| CActivityStatusManager | Covers the management of the StatusProperty in the State Manager that the prefab of an Activity node uses for transition animations |
| CActivitySwitchingSynchronizer | Encapsulates the synchronization of animations for activating and deactivating Activity nodes |
| CAndroidLogger | |
| CAnimationBindingProcessor | Animation binding processor executes an animation and calculates the value for use in expression bindings |
| CAnimationBindingProcessorRuntime | Holds the runtime state of an AnimationBindingProcessor |
| ►CAnimationPlayer | Use the Animation Player to play back an animation timeline that you set using the TimelineProperty property in that Animation Player |
| CCompletedMessageArguments | Message arguments for the Completed message |
| CPauseMessageArguments | Message arguments for the Pause message |
| CPlayMessageArguments | Message arguments for the Play message |
| CResumeMessageArguments | Message arguments for the Resume message |
| CStartedMessageArguments | Message arguments for the Started message |
| CStopMessageArguments | Message arguments for the Stop message |
| CStoppedMessageArguments | Message arguments for the Stopped message |
| CAnimationResource | A Resource wrapper class for animations |
| CApplication | Application class is the base class for Kanzi applications |
| ►CApplicationProperties | Configurable application properties |
| CFontEngineHasher | Class that provides the hash operator for the FontEngine enumeration |
| CImageLoadParameters | Parameters that Kanzi passes to third-party image libraries when loading image files |
| CSlog2Config | User configurable parameters for slogger2. Default values are set in the ApplicationProperties constructor |
| CTracingConfiguration | Tracing subsystem configuration |
| CAppliedStyleEntry | Applied style entry |
| CApplyAction | Base abstraction for Actions for DataTrigger, such as ForwardingApplyAction and ApplyActivationAction |
| CApplyActivationAction | An ApplyActivationAction keeps an Activity node activated for as long as the condition is met in a DataTrigger that contains this action |
| CApplyPropertyAction | An ApplyPropertyAction sets a property to the requested value for as long as the condition is met in the DataTrigger that sets off this action |
| CAutoClosingModalScope | Implements the auto-closing modal scopes |
| CAutoClosingModelessScope | Implements the auto-closing modeless focus scope |
| CBackEasingFunction | Changes the value back slightly before moving it toward the target |
| CBezierEasingFunction | Changes the value according to a Bezier curve |
| CBinaryResource | |
| CBinding | Binding is the simplest form of binding |
| CBindingBaseRuntime | Base runtime class for simple one-on-one bindings |
| CBindingExpressionOpCode | Expression binding operation |
| CBindingExpressionOpCodeParameters | Runtime Parameters for binding expression opcodes |
| CBindingGraphicsEntryLookupContext | Binding lookup context for graphics entries |
| CBindingHostConcept | BindingHostConcept specifies an interface for adding and removing bindings to the binding host |
| CBindingHostConceptImpl | Implementation class for BindingHostConcept |
| CBindingLoadInfo | Use the BindingLoadInfo to create the information for a binding that you need when adding the binding to an object |
| CBindingLookupContext | Lookup context for bindings |
| CBindingLookupNotificationBase | Base class for notifications on binding lookup |
| CBindingNodeEffect2DLookupContext | Binding lookup context for NodeEffect2D |
| CBindingNodeLookupContext | Binding lookup context for Node |
| CBindingProcessor | Binding processor |
| CBindingProcessorRuntime | Holds the runtime state of a binding processor |
| CBindingRenderPassLookupContext | Binding lookup context for RenderPass |
| CBindingRuntime | Runtime for binding |
| CBindingRuntimeHandle | Handler for binding runtimes |
| CBindingSource | Binding source contains all the persistent data that you need to access a source value for the binding |
| CBindingSourceRuntime | Binding source runtime interface |
| CBindingTargetRuntime | Binding target runtime interface |
| CBindingToken | Helper class that manages the lifetime of the runtime binding owned by a Node or a RenderPass, by removing the owned binding on the destruction of that Node or the RenderPass |
| CBindingTriggerLookupContext | Binding lookup context for Node |
| CBindingValueSourceOwner | Owner for value source bindings |
| CBindlessTextureRegistry | |
| ►CBitmapFontFile | Font implementation for bitmap fonts |
| CBitmapGlyphData | Derived GlyphData implementation for bitmap fonts |
| CKerningPairHasher | Class providing hash operator for bitmap font kerning pairs |
| CBitmapFontLoader | FontLoader implementation for bitmap fonts |
| CBitmapImage | Image is the basic runtime primitive to load, hold, and convert image data in memory |
| CBlendModeRenderStatePropertyNotificationHandler | Custom render state property notification handler for blend mode |
| CBlendModeRenderValueBindingTargetRuntime | Custom render value binding target runtime for blend mode |
| CBlendStateCache | Use a Blend State Cache to lookup a Kanzi graphics Blend State |
| CBlitRenderPass | Use the Blit Render Pass to blit one or more textures to the screen of the current rendering context using a material |
| CBlurEffect2D | Use BlurEffect2D to apply a Gaussian blur post-processing effect to 2D nodes |
| CBlurEffectRenderer2D | Blur effect renderer class |
| CBoolTranslator | Translates string into bool |
| CBounceEasingFunction | Changes the value as a sequence of bounces |
| CBox | Class for box volume |
| CBrush | Use a brush to fill a Node2D |
| CBrushRenderer | An interface for specialized brush renderers, which implement brush rendering |
| CBuildAccelerationStructureRenderPass | BuildAccelerationStructureRenderPass is a class for building acceleration structure for rendering nodes |
| CButton2D | Use the Button 2D node to create a 2D UI control that the user can interact with through clicking, tapping, or pressing a key |
| CButton3D | Use the Button 3D node to create a 3D UI control that the user can interact with through clicking, tapping, or pressing a key |
| ►CButtonConcept | Button nodes provide an area that receives key and touch input which Kanzi translates to state events |
| CCanceledMessageArguments | |
| CClickedMessageArguments | |
| CLongPressMessageArguments | |
| CPointerEnteredMessageArguments | |
| CPointerLeftMessageArguments | |
| CPressedMessageArguments | |
| CToggledOffMessageArguments | Message arguments used by the ToggledOffMessage |
| CToggledOnMessageArguments | Message arguments used by the ToggledOnMessage |
| CToggleStateChangedMessageArguments | Message arguments used by the ToggleStateChangedMessage |
| CButtonConceptImpl | Implementation class for ButtonConcept |
| CCallbackBindingProcessor | Callback processor |
| CCallbackProcessorRuntime | Holds the runtime state of a CallbackBindingProcessor |
| CCamera | Use a Camera to define the view transform to use to render a 3D Scene |
| CCaptureRequest | Token returned by captureFramebufferAsync() |
| CCharacterLayout | Structure for layout of a single character for text rendering |
| CCircleEasingFunction | Changes the value using a circular function |
| CClassPropertyDefaultValue | ClassPropertyDefaultValue is a helper for installing property values as class metadata |
| CClearRenderPass | Use a Clear Render Pass to clear the color, depth, and stencil buffers of the current render context before passing the control to the descendants of this render pass |
| CClickConcept | Use the ClickConcept properties to control how nodes handle click and double-click |
| CClickConceptImpl | Implementation of base Click Concept class for derived classes |
| ►CClickManipulator | Click input manipulator recognizes the click and tap gestures from the incoming touch events |
| CClickBeginMessageArguments | Message arguments for click gesture began message. Inherits argument properties from InputManipulator::InputMessageArguments |
| CClickCancelMessageArguments | Message arguments for click canceled message. Inherits argument properties from InputManipulator::InputMessageArguments |
| CClickEnterMessageArguments | Message arguments for pointer entering the node area message. Inherits argument properties from InputManipulator::InputMessageArguments |
| CClickLeaveMessageArguments | Message arguments for pointer leaving the node area message. Inherits argument properties from InputManipulator::InputMessageArguments |
| CClickMessageArguments | Message arguments for click gesture recognized message. Inherits argument properties from InputManipulator::InputMessageArguments |
| CClickManipulatorComponent | ClickManipulatorComponent installs a ClickManipulator to a node |
| CClock | Represents a monotonic, high resolution clock that advances steadily as the physical time moves forward |
| CCodeBehind | Code Behind is a workflow where you associate code with an instance of a node instead of a type |
| CCodeBehindRegisterGuard | RAII class for attaching code behind to an Activity or Activity Host node |
| CColorBrush | Color brush class |
| CColorBrushRenderer | Color brush renderer class |
| CColorRGBA | Color with 4 floating point components: red, green, blue and alpha (r, g, b, a) |
| CColorSpaceTranslator | Translates from string to meaningful surface color space string |
| CCombinerObjectSource | Combiner object source |
| CCombinerObjectSourceRuntime | Runtime for combiner object source |
| ►CCommand | Command class defines property and message types used in implementation of commands |
| CCommandMessageArguments | Represents the message arguments for command messages |
| ►CCommandRecorder | Use the command recorder to generate Kanzi graphics commands |
| CBufferStats | The statistics for a staging buffer |
| CCompositionBrush | Texture brush class |
| CCompositionBrushRenderer | OpenGL texture brush renderer class |
| CCompositionContentRequirements | Holds the requirements for the composition target |
| ►CCompositionManager | Composition manager |
| CLRUTracker | Least Recently Used wrapper for different resource types |
| CRequest | Composition request class |
| CReuseParameters | Reuse and pruning parameters for unused composition targets |
| CCompositionRequirements | Composition requirements represent the required buffers for composition |
| ►CCompositionStack | Composition stack for managing current render context |
| CColorBlendState | Blend state |
| CCompositionState | Composition target state |
| CDepthStencilState | Depth/Stencil state |
| CRasterizationState | Rasterization state |
| CStateStack | Template class for handling state arrays |
| ►CCompositionTargetRenderPass | Use the Composition Target Render Pass to set one to four composition targets and render all descendant render passes to the composition targets that the Composition Target Render Pass created |
| CCompositionSizeSettings | Size settings for Composition Target Render Pass |
| CComputeEntry | Host container for compute shader state |
| CComputeRenderPass | Use the Compute Render Pass to dispatch compute shader work using a material that references a compute shader program |
| CCondition | Condition for triggers |
| CConstraintBindingProcessor | Binding processor structure for constraints |
| CConstraintBindingProcessorRuntime | Holds the runtime state of a ConstraintBindingProcessor |
| CConstraints | Contains property types of Constraints |
| CContainsPropertyFilter | Use the Contains Property Filter to collect 3D nodes that contain, or do not contain a specific property |
| CContainsPropertyFilterRuntime | Runtime for contains property node filter |
| CContentBrush | Texture brush class |
| CContentBrushRenderer | Content brush renderer class |
| CContentItemCollectionModel | Base class for exposing abstract access to collections of items of UI controls with content |
| CContentItemModel | Base class for exposing abstract access to content of UI controls with single content item model |
| CContentLayout2D | Use the Content Layout 2D node to present content in a 2D UI control as a single item |
| CContentLayout3D | Use the Content Layout 3D node to present content in a 3D UI control as a single item |
| CContentLayoutConcept | Use the Content Layout nodes to present complex content as one element in the UI |
| CContentLayoutConceptImpl | ContentLayoutConceptImpl is an abstract class for implementing the Content Layout node concept |
| CContentReference | |
| CControllerPropertySource | Abstract class whose implementation encapsulates management of controller property source for an activity host controller property |
| CCoutLogger | This logger class writes log messages to standard output |
| CCubeMapRenderPass | Use the Cubemap Render Pass to create a cubemap texture that represents the scene from some location |
| CCubicEasingFunction | Changes the value based on the cube of time using the function f(t) = t^3 |
| ►CCurveReparametrization | Kanzi uses curve reparametrization to subdivide a spline or a line into a series of samples |
| CReparametrizationSample | A sample point (phase, length) for mapping between curve parameter and curve length |
| ►CDataContext | DataContext acts as a container for data |
| CModifiedSubscription | Subscription entry |
| CDataDrivenExclusiveActivityHost2D | A type of Exclusive Activity Host node, that uses a list of Activity nodes provided by setting a list DataObject, from a DataSource, to the ActivitySourceProperty property |
| CDataDrivenExclusiveActivityHost3D | A type of Exclusive Activity Host node, that uses a list of Activity nodes provided by setting a list DataObject, from a DataSource, to the ActivitySourceProperty property |
| CDataDrivenExclusiveActivityHostConcept | Base class for the Data-Driven Exclusive Activity Host classes |
| CDataDrivenExclusiveActivityHostImpl | Implementation class for DataDrivenExclusiveActivityHostConcept and ExclusiveActivityHostConcept |
| CDataObject | DataObject is the base class for data |
| CDataObjectBool | Implementation of DataObjectTyped<bool, DataObject::Bool> |
| CDataObjectEnum | Provides functions to the host, set, and get values of the given type |
| CDataObjectEnumBase | DataObjectEnumBase is the base class for enum data |
| CDataObjectInt | Implementation of DataObjectTyped<int32_t, DataObject::Int> |
| CDataObjectList | DataObjectList is the base class for list data object |
| CDataObjectReal | Implementation of DataObjectTyped<double, DataObject::Real> |
| CDataObjectString | Implementation of DataObjectTyped<string, DataObject::String> |
| CDataObjectTyped | Template class that you can use with the standard types |
| CDataObjectTypeTraits | DataObjectTypeTraits Provides type information for how a data type should be stored, passed as a parameter, etc |
| CDataObjectTypeTraits< double > | A specialization for double, because PropertyDataTypeTraits<T> does not have double |
| CDataSource | Use data sources to separate the user interface from the application data and to remove the dependencies between a Kanzi Studio project and the application code which define the Kanzi application |
| CDataSourceBindingSource | Data source binding source |
| CDataSourceBindingSourceRuntime | Runtime for object property binding source |
| CDataSourceControllerPropertySource | Implementation of ControllerPropertySource, for controller property value provided by a data source field |
| CDataSourceExpressionValueSource | Data Source expression value source |
| CDataSourceExpressionValueSourceRuntime | Runtime for object property expression value source |
| CDataSourceListBoxItemGenerator | |
| CDataSourceListBoxItemGenerator2D | |
| CDataSourceListBoxItemGenerator3D | |
| CDataTrigger | Use a DataTrigger to apply an action to either set a property value of a target node or activate an Activity node |
| CDataTriggerComponent | Base class for the DataTrigger class |
| CDataTriggerTemplate | DataTriggerTemplate is the base class for the Data Trigger templates |
| ►CDebugRenderRegistry | Use the debug render registry to register debug rendering functions for your custom Node3D nodes |
| CDebugRenderStorage | Storage class for storing visualizations used with debug rendering |
| ►CDebugVisualization | Class for displaying debug visualizations |
| CBoxSettings | Bounding volume storage |
| CCoordinateAxisSettings | Axis settings |
| CDirectionalLightSettings | Directional light settings |
| CEmptyObjectSettings | Empty object settings |
| CGridSettings | Grid settings |
| CRectangleSettings | Rectangle settings |
| CScopedDebugRenderSession | RAII helper class for coordinating two-phase debug rendering across multiple objects |
| CScopedOccludedPass | RAII helper class for rendering occluded parts of debug objects |
| CScopedVisiblePass | RAII helper class for rendering visible parts of debug objects |
| CSpotLightSettings | Spot light settings |
| CDebugVisualizationStorage | Storage class for debug visualizations |
| CDefaultListBoxGridPresenter | |
| CDefaultListBoxItemContainerGenerator | |
| CDefaultListBoxItemGenerator | |
| CDefaultListBoxTrajectoryPresenter | |
| CDefaultLogger | Use this class to access the Default Logger |
| CDefaultProfilerRegistry | The default profiler registry placeholder |
| CDelegate | Multicast delegate — holds zero or more callbacks with the same signature and invokes them all |
| CDelegateHandle | Opaque handle returned by Delegate::subscribe() |
| CDenoiser | Abstract base class for denoising algorithms used with ray traced render passes |
| CDenoiserRenderPass | DenoiserRenderPass hosts a Denoiser implementation and drives it each frame within the render graph |
| CDepthStencilStateCache | Use a Depth Stencil State Cache to lookup a Kanzi graphics Depth Stencil State |
| CDispatchMessageAction | DispatchMessageAction dispatches a message of specified type to a specified target |
| CDistanceFilter | Distance filter |
| CDistanceFilterRuntime | Runtime for distance filter |
| CDockLayout2D | Use the Dock Layout 2D node to place nodes relative to each other along the sides of a Dock Layout 2D node |
| CDockLayout3D | Use the Dock Layout 3D node to place nodes relative to each other along the sides of a Dock Layout 3D node |
| CDockLayoutConcept | Dock layout concept base class |
| CDockLayoutConceptImpl | Dock layout concept implementation base class |
| CDomain | Domain binds Kanzi subsystems and objects together |
| CDomainController | Base class for the host that drives a Domain |
| CDomainProfilerCollection | The domain profiler collection |
| ►CDragAndDropManipulator | Drag-and-drop input manipulator recognizes the drag-and-drop gesture from incoming touch events |
| CCanceledMessageArguments | Message arguments for the drag-and-drop cancel message |
| CFinishedMessageArguments | Message arguments for drag-and-drop finished message. Inherits argument properties from InputManipulator::InputMessageArguments |
| CMovedMessageArguments | Message arguments for drag-and-drop moved message. Inherits argument properties from InputManipulator::InputMessageArguments |
| CStartedMessageArguments | Message arguments for drag-and-drop started message. Inherits argument properties from InputManipulator::InputMessageArguments |
| ►CDrawObjectsRenderPass | Use the Draw Objects Render Pass to render only nodes in a Scene node provided by an object source you set in this render pass |
| CCommonUBOs | Shared uniform buffer uploads for one render pass |
| CDrawObjectsWithMaterialRenderPass | Use the Draw Objects With Material Render Pass to render nodes provided by an object source using a material |
| CDummyBindingTargetRuntime | Runtime for dummy binding target |
| CDynamicMessageType | DynamicMessageType is a handle to an existing message type |
| CDynamicPropertyType | DynamicPropertyType is a handle to an existing property type |
| CEffectStack2D | Use EffectStack2D to apply multiple post-processing effects to 2D nodes |
| CEffectStackRenderer2D | Use the Effect Stack Renderer to render a sequence of child effect renderers |
| CEGLCapabilities | EGL capabilities |
| CEGLConfig | Class representing a single EGL configuration |
| CEGLContext | Class representing an EGL context |
| CEGLContextClientVersionTranslator | Translates from string to meaningful EGL Context client version string |
| CEGLDisplay | Class representing an EGL display connection |
| CEGLIMGContextPriorityTranslator | |
| CEGLPBufferSurface | Class representing EGL PBuffer surface |
| CEGLPixmapSurface | Class representing EGL pixmap surface |
| CEGLSurfaceTypeTranslator | Translates from string to meaningful EGL surface type string |
| CEGLVersion | Struct holding EGL version information |
| CEGLWindowSurface | Class representing EGL window surface |
| CElasticEasingFunction | Changes the value that resembles an oscillating spring until it comes to rest |
| CEmptyNode2D | Empty Node 2D can be used to group other 2D nodes |
| CEmptyNode3D | Use an EmptyNode3D to group 3D nodes |
| Cenable_bitmask_operators | Enabler template for bitmask operators over an Enum class |
| CEventFilter | EventFilter class |
| CEventQueue | Implements a queue of Kanzi input events gathered by EventSource instances |
| CEventScope | Helper class to manage an event scope |
| CEventScope< TCategory, TString, false > | |
| CEventSource | EventSource class |
| CEventSourceDecorator | The EventSourceDecorator declares the interface for the EventSource decorators |
| CEventSourceProperties | Configurable event source properties |
| CExampleApplication | |
| CExclusiveActivityHost2D | An Activity Host that displays Activity nodes one at a time |
| CExclusiveActivityHost3D | An Activity Host that displays Activity nodes one at a time |
| CExclusiveActivityHostBaseImpl | Implementation of common functionality of ExclusiveActivityHost and DataDrivenExclusiveActivityHost classes |
| ►CExclusiveActivityHostConcept | This is the base class for all Exclusive Activity Host nodes |
| CActivityInExclusiveHostInfo | Stores information that identifies an Activity node under an ExclusiveActivityHost |
| CExclusiveActivityHostContent | Container for the content information for an ExclusiveActivityHost |
| CGoToFallbackStateMessageArguments | Message arguments for GoToFallbackState message |
| CImplicitActivityChangeRequestMessageArguments | Base class for Exclusive Activity Host Concept message argument classes |
| CExclusiveActivityHostContentHandler | Helper class used to modify the ExclusiveActivityHostContent of an ExclusiveActivityHost |
| CExclusiveActivityHostImpl | Implementation class for ExclusiveActivityHost |
| CExecuteLuaAction | You can use ExecuteLuaAction to run a Lua script that implements application logic |
| CExponentialEasingFunction | Changes the value with an exponential function with power that you can configure |
| CExpressionBinding | ExpressionBinding enables you to bind from multiple sources to one target, and to modify the values before writing them to target values |
| CExpressionBindingProcessor | Expression binding processor |
| CExpressionBindingRuntime | Runtime for expression binding |
| CExpressionBindingSource | Expression binding source collects expression value sources and executes operations on the values to produce a read result |
| CExpressionBindingSourceRuntime | Runtime for expression binding source |
| CExpressionCondition | Use trigger conditions to set which conditions must be met for a Trigger to set off |
| CFile | Interface class for files |
| CFilterObjectSource | Filter object source |
| CFilterObjectSourceRuntime | Base class for filter runtime classes |
| CFixedArray | |
| CFixedString | String that points to a string literal |
| CFlagScopeGuard | Scope guard for boolean value |
| CFlagWaiter | Waiter object that can block the calling thread until a flag is set |
| CFlatOptional | Optional-like lightweight wrapper around type T with no space overhead |
| ►CFloatValueAccumulator | Use a FloatValueAccumulator to increase the value of a float property type or a property field over time or per frame |
| CSetAccumulatedValueBoundariesMessageArguments | Message arguments for the SetAccumulateValueBoundaries message |
| CFlowLayout2D | Flow Layout 2D arranges 2D items along a line and continues to the next line when it runs out of space |
| CFlowLayout3D | Flow Layout 3D arranges 3D items along a line and continues to the next line when it runs out of space |
| CFlowLayoutConcept | Flow layout concept base class |
| CFlowLayoutConceptImpl | Flow layout concept implementation base class |
| CFocusChainIndex | Contains the focus order and focus order offset information of a node in a focus scope |
| CFocusChainNode | The focus chain node of a focus scope consists of the node of the focus scope, its focus order, and the focus order offset |
| CFocusFence | Implements the focus fences |
| CFocusGroup | Implements the focus groups |
| ►CFocusManager | Focus Manager enables you to set and change the key focus between attached nodes |
| CFocusEnteredFocusScopeMessageArguments | Message arguments used by the FocusEnteredFocusScopeMessage |
| CFocusLeftFocusScopeMessageArguments | Message arguments used by the FocusLeftFocusScopeMessage |
| CInputOutsideOverlayMessageArguments | Message arguments used by the InputOutsideOverlayMessage |
| CMoveFocusMessageArguments | Message arguments used by the focus move messages |
| COverlayBroughtToFrontMessageArguments | Message arguments used by the OverlayBroughtToFrontMessage |
| COverlayGainedFocusMessageArguments | Message arguments used by the OverlayGainedFocusMessage |
| COverlayLostFocusMessageArguments | Message arguments used by the OverlayLostFocusMessage |
| COverlaySentToBackMessageArguments | Message arguments used by the OverlaySentToBackMessage |
| CPostFocusMessageArguments | |
| CPreFocusMessageArguments | Message arguments for the pre-focus messages |
| CScopeStateChangeMessageArguments | Base message argument class for the focus scope state change message arguments |
| CFocusNavigationGesture | Declares a focus navigation gesture |
| CFocusNavigationManipulator | FocusNavigationManipulator converts key gestures into focus chain navigation actions to move the focus between focusable nodes |
| ►CFocusScope | Holds the attributes of a focus scope: |
| CFocusChain | The FocusChain contains the snapshot of the focus chain of a focus scope |
| CFocusScopeVisitor | Focus scope visitor for UI scene traversal of focus scopes |
| ►CFontEnginePlugin | FontEnginePlugin is the interface definition for font engine plugins |
| CBackendProperties | Font backend properties |
| CFontEngineTranslator | Translates font engine backend from string to ApplicationProperties::FontEngine enum value |
| CFontFamily | A font family resource contains font files |
| ►CFontFile | FontFile is the base class for different font file resource implementations |
| CGlyphData | GlyphData contains the metrics for an individual rendered glyph and its bitmap |
| CFontLoader | Use FontLoader to create FontFile objects from memory or a file |
| CFontManager | Use the FontManager class to: |
| CFontRuntime | Runtime font |
| CFontStyleConcept | FontStyleConcept is the base class for the nodes that draw text with different font styles |
| CFontStyleConceptImpl | Implementation class for FontStyleConcept |
| CFontStyleDefinition | FontStyleDefinition provides a collection of font characteristics |
| ►CForwardingAction | ForwardingAction is the base class for the action classes that read and send arguments, such as SetPropertyAction or DispatchMessageAction |
| CBindingEntry | Entry for bindings to install when the action is invoked |
| CBindingRuntimeEntry | Entry for binding runtimes to execute when the action is invoked |
| ►CForwardingApplyAction | ForwardingApplyAction is the base class for the ApplyAction classes that read and send an argument, such as ApplyPropertyAction |
| CBindingInfo | Stored info for a binding |
| ►CFramebuffer | Framebuffer attachment state |
| CAttachmentData | Optional attachment information |
| ►CAttachmentPoint | Attachment point |
| CRenderbufferContainer | Container for renderbuffer information |
| CTextureContainer | Container for weak texture reference |
| CResolveTarget | Resolve target |
| CFramebufferBase | Base abstraction class for Framebuffer classes |
| CFramebufferGraphicsOutput | FramebufferGraphicsOutput class |
| CFrameDescription | Description of a frame, the remaining area of a quad with another quad cut out |
| ►CFrameTimeQueue | Bookkeeping for frame durations and associated errors |
| CErrorTermCalculator | Error term calculator |
| CFreeTypeFontEnginePlugin | FreeTypeFontEnginePlugin is the FreeType font engine plugin implementation |
| CFreeTypeFontFile | Font implementation using the Freetype rasterizer |
| CFreeTypeFontLoader | FontLoader implementation for the Freetype rasterizer |
| CFreeTypeTextShaper | TextShaper implementation using these open source libraries: |
| CFromToAnimation | Template class for from-to animations |
| CFromToAnimationBase | Template base class for from-to animations |
| CFrustumCullFilter | Frustum cull filter |
| CFrustumCullFilterRuntime | Runtime for frustum cull filter |
| ►CGatherLightsRenderPass | GatherLightsRenderPass is a class for generating light properties for rendering nodes |
| CInstantiatorNotification | Instantiator notification information installed by the gather lights render pass |
| CLightInfo | Internal information structure for storing information on lights |
| CLightRange | Light range is a range type for retrieving light values |
| ►CGatherNearestLightsRenderPass | GatherNearestLightsRenderPass is an implementation of light gathering |
| CLightDistanceInfo | Light distance information |
| ►CNearestLightRange | Nearest light range is an extension to light range that returns the lights in distance order to caller |
| CNearestLightRangeLocation | Light range location implementation |
| ►CGenericResourceProfilingContext | Generic resource profiling context |
| CSampler | The context sampler |
| ►CGeometry | Geometry represents 2D coordinate data that you can use to render 2D nodes and text |
| CVertex | Vertex for geometry |
| ►CGlyphCache | Glyph cache renders different characters on a texture with the font and font size that you use in your Kanzi application |
| CTextureCoordinates | Coordinates to the position of a single glyph in a glyph cache texture |
| CGlyphCacheManager | GlyphCacheManager creates and maintains glyph caches for different font file and font size combinations |
| CGlyphRun | GlyphRun contains the memory structures that are needed to render a text string |
| ►CGPUBuffer | Buffer abstraction |
| CCreateInfo | CreateInfo The create info for creating a GPUBuffer |
| CGPUResource | GPUResource is a resource that must be deployed to the GPU |
| CGPUScene | GPUScene tracks scene geometry, materials, and instances on the GPU for use in bindless and ray tracing pipelines |
| CGPUSceneInfo | |
| CGPUSceneInstanceInfo | |
| CGPUSceneMeshInfo | |
| CGraphicsContextAPITranslator | Translates graphics context API property from string to GraphicsContextAPI |
| CGraphicsEntry | Base class for graphics entries |
| CGraphicsOutput | GraphicsOutput class |
| CGridLayout2D | Grid Layout 2D arranges 2D items in a grid |
| CGridLayout3D | Grid Layout 3D arranges 3D items in a grid |
| ►CGridLayoutConcept | Base class for the Grid Layout nodes |
| CRowColumnDefinition | Definition for the size and position of a single row or column |
| ►CGridLayoutConceptImpl | Implementation class for GridLayoutConcept |
| CGridObjectLocationWorkspace | Information used to store the state between function calls when locating objects |
| CGridListBox2D | Use the Grid List Box 2D node to create scrollable lists of 2D items arranged in a grid |
| CGridListBox3D | Use the Grid List Box 3D node to create scrollable lists of 3D items arranged in a grid |
| CGridListBoxConcept | GridListBoxConcept provides the common properties and messages for the GridListBox2D and GridListBox3D nodes |
| CGridListBoxConceptImpl | Implementation class for GridListBoxConcept |
| CGridListBoxTraits | Template helper class which defines a Grid List Box traits |
| CHandle | Represents a handle that was created by an external source |
| CHandleGPUResourcesTranslator | Converts string to handle GPU resources setting |
| Chash< kanzi::platform::GlGraphicsContext::SurfaceContextHandle > | |
| Chash< kanzi::platform::GlGraphicsContext::SurfaceHandle > | |
| Chash< kanzi::platform::GlGraphicsContext::ThreadContextHandle > | |
| CHudDebugEvent | The event toggles the head-up display debugging status |
| CImage2D | Image2D node |
| CImmutableIteratorRange | Iterator location range pointing to a particular location of an iterator range |
| CImmutableSplitStringRange | ImmutableSplitStringRange is an analogue to the ImmutableIteratorRange for a SplitStringRange |
| CImmutableString | Immutable string container |
| ►Cindexed_list | Indexed list container |
| Cconst_iterator | Const iterator over the values |
| Celement_type | Value type for internal container |
| Citerator | Iterator over the values |
| CIteratorBase | Base class for iterator and const_iterator |
| Csorting_type | Sorting value type |
| ►CIndexedPropertyAccessRange | Indexed property access range |
| CIndexedPropertyAccessRangeLocation | Location implementation for indexed property access range |
| ►CIndexedViewRange | View over another indexed range |
| CIndexedViewRangeLocation | Location class for indexed view range |
| CInputEvent | Base event class providing the core functionality of the Kanzi input events |
| CInputManager | Input Manager converts the events from the given event queue into input specific messages |
| ►CInputManipulator | The base class for the Kanzi input manipulators |
| CCollection | Common functions of collections of attached InputManipulators processing a specific input event type |
| CInputMessageArguments | Message arguments for input manipulator messages |
| CKeyInputMessageArguments | Represents base message arguments for key input messages |
| CTouchInfo | Structure to hold the state of the current touch points |
| CInputMethod | The InputMethod class defines the interface of the Kanzi input methods |
| CInputMethodBackend | The InputMethodBackend defines the interface of the input method backends |
| CInputMethodListener | The InputMethodListener defines the communication interface of Kanzi input methods |
| CInputMethodManager | The InputMethodManager keeps track of the input method backends registered in Kanzi |
| CInputTranslationTranslator | Translates input translation property from string to InputTranslation |
| CInstanceAccelerationStructure | An acceleration structure contains data used by ray tracing for single instance/geometry (BLAS) |
| ►CInstantiator3D | Use the Instantiator node to replicate the appearance of a 3D node, or a tree of 3D nodes, that the Instantiator node targets |
| CFinalTransformModifier | Container for property modifiers for instantiated nodes |
| CInstructionBindingProcessor | Instruction binding processor is the top-level class for all instruction-like binding processors |
| CInstructionBindingProcessorRuntime | Holds the runtime state of an InstructionBindingProcessor |
| CInterpolatedValue | Core component for smooth interpolation in code |
| CIntervalProfiler | The interval profiler |
| CIntervalProfilerSampleData | The interval profiler data sample |
| CIntervalProfilerSampleStatistics | |
| CIntervalProfilingSampler | The main loop task profiling sampler collects interval measurement to produce IntervalProfilerSampleData sample |
| ►CIntValueAccumulator | Use an IntValueAccumulator to increase the value of an integer property type over time or per frame |
| CSetAccumulatedValueBoundariesMessageArguments | Message argument for SetAccumulatedValueBoundaries message |
| CInvalidKZBFileException | Kanzi throws this exception when it tries to load an invalid kzb file |
| CInvalidKZBMagicException | Kanzi throws this exception when a kzb file has invalid file signature |
| CIPatchHandler | Patch handler interface |
| CIrisImageHeader | |
| ►CIteratorRange | Iterator is an range that references a location in another range |
| CIteratorRangeLocation | Location implementation for iterator range |
| CItypeFontEnginePlugin | ItypeFontEnginePlugin is the IType font engine plugin implementation |
| ►CItypeFontFile | Font implementation using the iType rasterizer |
| CItypeBitmapData | GlyphData implementation for iType CBDT fonts |
| CItypeGlyphData | Derived GlyphData implementation for iType |
| CItypeFontLoader | FontLoader implementation for Monotype's iType rasterizer |
| ►CItypeTextShaper | TextShaper implementation using Monotype's WTShaper library |
| CFontData | Runtime data for text layouting to be passed to WTShaper |
| CJavaException | Exception class that can be used to wrap a Java generated exception |
| CJavaModule | |
| CJNIError | |
| CJniLibrary | |
| CJvmModule | |
| CKanziComponentsModule | |
| CKeyEvent | The KeyEvent holds a pressed, released, or auto-repeated key event that occurs in the host operating system |
| ►CKeyframeAnimation | Template class for keyframe animations |
| CBezierKeyframe | Use bezier keyframes to animate property value along a bezier curve |
| CKeyframe | Keyframe defines a value for the animated property at a specific time in an animation timeline |
| CLinearKeyframe | Use linear keyframes to interpolate animated property value linearly between keyframes |
| CStepKeyframe | Use Step keyframes to keep the value of the current keyframe constant up until the following keyframe |
| CKeyGestureInfo | This class defines the elements that compose a key gesture, key values, and key modifiers |
| ►CKeyManipulator | KeyManipulator class is a key input manipulator that detects key gestures |
| CKeyCanceledMessageArguments | Message arguments used by the KeyCanceledMessage |
| CKeyPressedMessageArguments | Message arguments used by the KeyPressedMessage |
| CKeyReleasedMessageArguments | Message arguments used by the KeyReleasedMessage |
| CKeyManipulatorComponent | The KeyManipulatorComponent node component installs a KeyManipulator to the attached node, and configures the key gesture of the manipulator |
| CKeyMap | Defines the keys to map from a {LogicalKey, KeyModifier} pair to a simple LogicalKey |
| CKeyMapEventFilter | The KeyMapEventFilter provides key translation in Kanzi |
| CKeyRepeatGenerator | The KeyRepeatGenerator is an event source decorator that scans the event queue of the EventSource it extends for key-press events and generates from them key-press repetitions |
| CKzbFile | Kzb file loader |
| CKZBFileException | Kanzi throws this exception when an error occurs while loading a kzb file |
| CKzbMemoryParser | Parser for kzb files |
| CLegacyError | |
| CLegacyEventSource | LegacyEventSource class |
| CLegacyGraphicsOutput | LegacyGraphicsOutput class |
| CLibJPEGParameters | Parameters that Kanzi passes to libjpeg to use when loading jpg image files |
| CLibPNGParameters | Parameters that Kanzi passes to libpng to use when loading png image files |
| CLight | Light node is a source of light for a 3D scene |
| CLightBuffer | Packs gathered lights into a std140 uniform buffer with 6 vec4s per light |
| CLightBufferHeader | Light buffer header (std140 layout) |
| CLightData | Per-light data (std140 layout) |
| CLinearEasingFunction | Changes the value with constant velocity |
| CLinearFramebuffer | LinearFramebuffer class is a temporary render target for linear color workflow |
| ►CListBoxConcept | Properties and messages for list boxes |
| CItemLoadedMessageArguments | Message arguments for the messages about the new loaded item in a List Box node |
| CItemMessageArguments | Base class for item-related message arguments |
| CItemSelectedMessageArguments | Message arguments for the messages about the item selected event in a List Box node |
| CItemUnloadedMessageArguments | Message arguments for the messages about item unloading in a List Box node |
| CMoveFocusMessageArguments | Message arguments for the message about the focus move execution received on a List Box node |
| CTrySetFocusToItemMessageArguments | Message arguments for the message about the set focus execution received on a List Box node |
| CListBoxConceptImpl | ListBoxConceptImpl provides the common base implementation for the List Box nodes, such as GridListBox2D, GridListBox3D, and TrajectoryListBox3D |
| CListBoxGridPresenter | ListBoxGridPresenter implements the List Box presenter that use Scroll View and the grid layout in their presentation |
| CListBoxItemContainer | Use the List Box Item Container prefab to create common functionality and decoration for all items in a List Box |
| CListBoxItemContainer2D | List Box Item Container for 2D List Box nodes |
| CListBoxItemContainer3D | List Box Item Container for 3D List Box nodes |
| CListBoxItemContainerGenerator2D | |
| CListBoxItemContainerGenerator3D | |
| CListBoxItemContainerImpl | Implementation of base List Box Item Container class for List Box |
| CListBoxItemGenerator2D | |
| CListBoxItemGenerator3D | |
| ►CListBoxScrollingConcept | Messages for the List Box nodes that implement scrolling |
| CScrolledMessageArguments | Message arguments for the messages about the scrolled event in a List Box node |
| CScrollFinishedMessageArguments | Message arguments for the messages about the scroll finished event in a List Box node |
| CScrollMessageArguments | Base class for scroll-related message arguments |
| CScrollStartedMessageArguments | Message arguments for the messages about the scroll started event in a List Box node |
| CTargetChangedMessageArguments | Message arguments for the messages about the changed scroll target in a List Box node |
| CUserScrollFinishedMessageArguments | Message arguments for the messages about the user scroll finished event in a List Box node |
| CUserScrollStartedMessageArguments | Message arguments for the messages about the user scroll started event in a List Box node |
| CListBoxScrollPresenterConceptImpl | ListBoxScrollPresenterConceptImpl is the base class concept implementation for the List Box presenters that use Scroll View in their presentation |
| ►CListBoxTrajectoryPresenter | ListBoxTrajectoryPresenter implements the List Box presenter that use Scroll View and the trajectory layout in their presentation |
| CTrajectoryLayoutSnapInfo | |
| CVirtualListBoxItem | Represents a virtual item within a ListBox |
| CLoadedPlugin | RAII handle owning a dynamically loaded plugin shared library and the Module instance the library produced via its createModule() entry point |
| CLoadGPUBufferCreateInfoResult | Result of loading GPUBuffer creation parameters from a KZB file |
| ►CLongPressManipulator | Long-press input manipulator recognizes the long-press gesture from the incoming touch events |
| CLongPressCancelMessageArguments | Message arguments for long-press canceled message |
| CLongPressMessageArguments | Message arguments for long-press gesture recognized message. Inherits argument properties from InputManipulator::InputMessageArguments |
| CLongPressManipulatorComponent | LongPressManipulatorComponent installs a LongPressManipulator to a node |
| CLuaDataSource | Use Lua data source to define the format and structure of your data in the Lua script |
| CLuaInstance | Loads and runs Lua scripts |
| CLuaModule | The Lua plugin enables you to program Kanzi applications using the Lua programming language |
| CMainLoopProfiler | MainLoopProfiler implements profiling for tasks of MainLoopScheduler |
| CMainLoopProfilingAggregateData | MainLoopProfilingAggregateData implements profiling data aggregation for MainLoopProfiler |
| CMainLoopProfilingSampleData | MainLoopProfilingSampleData implements profiling sample data for MainLoopProfiler |
| CMainLoopProfilingSampler | MainLoopProfilingSampler implements profiling sampler for MainLoopProfiler |
| ►CMainLoopScheduler | MainLoopScheduler implements the Kanzi application main loop in form of a customizable sequence of stages, each consisting of a sequence of tasks, where a task is any callable, including functions, function objects, and lambdas |
| CTaskInfo | TaskInfo is a structure containing information related to a task |
| CManualBinding | Manual binding is a one-to-one binding that caches the value that was written to the target |
| CManualBindingRuntime | Runtime for binding |
| CManualBindingSource | Manual binding source |
| CManualBindingSourceRuntime | Runtime for manual binding source |
| CManualBindingTargetRuntime | Runtime for manual binding target |
| CMaskEffect2D | Use MaskEffect2D to apply a mask to 2D nodes |
| CMaskEffectRenderer2D | Mask effect renderer class |
| CMaterial | A material is an instance of a material type (ShaderProgram) that contains the property values for the material type properties |
| CMaterialBrush | Freeform shader brush |
| CMaterialBrushRenderer | Material brush renderer |
| CMaterialRequirements | Representation of material requirements as a fast-searchable bit field |
| CMaterialSetupRenderPass | Use the Material Setup Render Pass to set properties to a material for further render operations using that material |
| CMaterialVariationMapping | Mapping from material requirements to representing derived types |
| CMatrix3x3 | Matrix with 3x3 elements |
| CMatrix3x3Translator | Translates from string to matrix 3x3 |
| CMatrix4x4 | Matrix with 4x4 elements |
| CMemoryParser | |
| CMemoryWriter | |
| ►CMesh | Mesh stores the geometry data for rendering Model3D nodes |
| CBone | Definition of mesh bone that is used for mesh skinning |
| CCluster | Cluster has a material, primitive type (currently always triangles), and handle for GPU memory buffer where primitive indices are stored |
| ►CCreateInfo | Use Mesh::CreateInfo to describe and create meshes |
| CAdjustment | Describes a single adjustment made by adjustForDeviceCapabilities() |
| CAdjustmentKey | Named keys for Adjustment parameter maps |
| CCluster | Parameters for Mesh::Cluster creation |
| ►CMorphData | Morph data associated with deforming this mesh |
| CMorphShape | Morph shape |
| ►CMorphData | Morph data associated with deforming this mesh |
| CMorphShape | Morph shape |
| CSkeleton | Skeleton is for animating mesh with bones |
| CVertexInputStateUsage | |
| CMeshVertexAttribute | MeshVertexAttribute describes how Kanzi stores mesh vertex and instance data in memory, and (in CreateInfo context) carries the source data for the attribute |
| CMeshVertexFormat | Vertex format information |
| ►CMessageArguments | MessageArguments is the base class for arguments passed in messages |
| CArgumentEntry | Linked list entry containing arguments type and value |
| CMessageBindingSource | Message binding source |
| CMessageBindingSourceRuntime | Runtime for message binding source |
| CMessageBindingTargetRuntime | Runtime for message binding target |
| CMessageTrigger | Message handler trigger |
| CMessageType | An instance of a MessageType represents a single message type in the Kanzi message system |
| CMetaclass | Metaclass provides type inspection mechanism for Kanzi classes |
| CMetaclassAbstractBase | |
| CMetaclassAbstractImpl | |
| CMetaclassImpl | |
| CMetaclassStaticBase | |
| CMetaclassStaticImpl | |
| CMetadataGeneratedName | This class is used to disambiguate a constructor which takes a non-literal string argument from an overload which takes a string-literal i.e. FixedString |
| CMetaMethod | MetaMethod provides method invocation mechanism for Kanzi classes |
| CMetaObject | MetaObject is the base class for classes that provide type reflection |
| CMethodArgument | Holds argument type and value information |
| CMethodArguments | Holds arguments applied on metamethod invocation |
| CMillisecondTranslator | Translates time from string in milliseconds to chrono::duration type |
| CMipmapGenerationConcept | Use the MipmapGenerationConcept properties to control mipmap generation material of a Render Pass |
| ►CMipmapGenerationConceptImpl | Implementation of base Mipmap Generation Concept class for derived classes |
| CMipmapAttachment | Container for data related to rendering into a single mipmap attachment |
| CMipmapFramebufferLevel | Mipmap framebuffer level |
| CMipmapRenderData | Defines the data required when custom mipmap material has been specified |
| CModalScope | Implements the modal scopes |
| CModel3D | Node for rendering meshes in 3D space |
| CModelessScope | Implements the modeless overlay focus scopes |
| CModule | Module is a class representing a functional module with its own metadata about the types it contains |
| CModuleDeleter | Module deleter for shared_ptr |
| CModuleNameListTranslator | Translates from string to module name list |
| CMoveFocusAction | Use the MoveFocusAction action to transfer focus from the currently focused item to another focusable item in the focus navigation chain |
| ►CMultiClickManipulator | Multi-click input manipulator recognizes multi-click and multi-tap gestures from incoming touch events |
| CCanceledMessageArguments | Message arguments for multi-click cancel message |
| CMultiClickMessageArguments | Message arguments for the multi-click gesture recognized message. Inherits argument properties from InputManipulator::InputMessageArguments |
| CMultiClickManipulatorComponent | MultiClickManipulatorComponent installs a MultiClickManipulator to a node |
| CNamedIntervalProfiler | The named interval profiler |
| CNamedIntervalProfilerSampleData | The named interval profiler data sample |
| CNamedIntervalProfilerSampler | This sampler collects interval measurement to produce NamedIntervalProfilerSampleData sample |
| CNamedIntervalProfilerSampleStatistics | Named Interval profiler sample statistics |
| ►CNamedResourceProfilingContext | Named resource profiling context |
| CSampler | The context sampler |
| CNativeDeploymentTarget | Reference to a backend implementation specific memory storage type for deployment |
| CNativeDesktopProperties | Properties for a desktop |
| CNativeWindowProperties | Properties for a window |
| CNavigationGesture | Declares a navigation gesture |
| ►CNavigationManipulator | The NavigationManipulator supports these navigation directions and default keyboard keys for them: |
| CKeyNavigationMessageArguments | |
| CNavigationManipulatorComponent | The NavigationManipulatorComponent node component installs a NavigationManipulator to a node, and configures the navigation key gestures of the manipulator |
| CNinePatchImage2D | A nine-patch image is a 3x3 grid of images |
| ►CNode | Base class for Kanzi nodes |
| ►CMessageSubscription | Message subscription structure |
| CLessFunctor | |
| CMessageSubscriptionToken | Message subscription token for nodes |
| CNodeComponentEntry | Node component entry |
| ►CNode2D | Node2D is the base class of 2D nodes |
| CClippingArea | Clipping information carried from parents |
| CNode3D | Base class for all 3D nodes |
| ►CNodeComponent | NodeComponent is the base class for all node components |
| CNodeComponentSourceMessageArguments | Base class for message arguments that are sent by a node component |
| CNodeComponentTargetMessageArguments | Base class for message arguments that are sent to a node component |
| CNodeComponentTemplate | NodeComponentTemplate is the base class for all node component templates |
| ►CNodeCompositor2D | Composition functionality for 2D nodes |
| CCompositionState | CompositionState defines the state held by the compositor while Kanzi performs the composition, that is, between calls to beginComposition and blitComposition |
| CGeometryState | GeometryState defines the state used for rendering a quad |
| CNodeEffect2D | Use node effects to apply post-processing effects to 2D nodes |
| CNodeEffectPrefab2D | Use node effect prefabs to create node effects that define post-processing effects for 2D nodes |
| ►CNodeEffectRenderer2D | Node effect renderer class |
| ►CEffectPass | Effect pass configuration |
| CInput | Effect pass input configuration |
| ►CEffectRenderState | Render state configuration to use with an effect pass |
| CInput | Render state texture input configuration |
| CNodeEffectTemplate2D | Use NodeEffectTemplate2D to instantiate a node effect |
| CNodeList | NodeList is a container that works as input and output node listing for filtering and rendering |
| CNodeListRenderPass | Use the Node List Render Pass to filter and hold a list of nodes that you want to render using other render passes |
| CNodePropertyNotificationHandler | Node property notification handler |
| CNodeReference | Provides functionality for a reference to any attached node that you can access using a relative path |
| ►CNodeVisual2D | Data and functionality required for rendering Node2D visuals |
| CBrushState | State associated with brush rendering |
| CNullBrush | Null brush class |
| CNullGraphicsOutput | NullGraphicsOutput class |
| Cnullptr_t | Nullptr_t is the type of the null pointer literal, nullptr |
| CObject | Object is the base class for Kanzi UI classes that implement association with a Domain |
| CObjectControllerPropertySource | Implementation of the ControllerPropertySource, for ControllerProperty value provided as a property field, either on the Activity Host node or, if the Activity Host node does not have that property, its nearest ancestor that does have that property |
| CObjectFactory | Factory for creating objects based on metaclass type |
| CObjectLoader | ObjectLoader loads objects from KZB |
| CObjectPropertyBindingSource | Object property binding source |
| CObjectPropertyBindingSourceRuntime | Runtime for ObjectPropertyBindingSource |
| CObjectPropertyExpressionValueSource | Object Property expression value source |
| CObjectPropertyExpressionValueSourceRuntime | Runtime for object property expression value source |
| CObjectPropertyListenerImpl | Object property listener implementation |
| CObjectSource | Structure for object source |
| CObjectSourceRuntime | Runtime for an object source |
| CObjectTimelinePlaybackContext | Timeline playback context that resolves paths relative to a plain Object rather than a scene graph node |
| CObjectTypeFilter | Use the Object Type Filter to collect 3D nodes based on their type |
| CObjectTypeFilterRuntime | Runtime for object type filter |
| COnAttachedTrigger | On Attached Trigger |
| COnPropertyChangedTrigger | Invokes associated actions on setting of a property type, specified by SourcePropertyTypeProperty, on a source node, specified by SourceNodeProperty |
| COptionalHandle | Represents a handle that was created by an external source |
| COptionalHandleWrapper | Creates a wrapper around an OptionalHandle class |
| COrientationChangedEvent | Specialized event that reports the orientation change of a window |
| COrientedBoundingBox | An oriented bounding box represents a bounding box that has been transformed by a transformation matrix |
| COutlineEffect2D | Use OutlineEffect2D to apply an outline to the content of 2D nodes |
| COutlineEffectRenderer2D | Outline effect renderer class |
| COverlayScope | Implements the base of overlay focus scopes |
| ►CPage | Use Page nodes to create the structure of an application user interface |
| CActivatedMessageArguments | Represents message arguments of Activated message |
| CDeactivatedMessageArguments | Represents message arguments of Deactivated message |
| CNavigateMessageArguments | Represents message arguments of Navigate message |
| CNavigateParentMessageArguments | Represents message arguments of NavigateParent message |
| CNavigationActivatedMessageArguments | These messages are used by the page navigation logic internally |
| CNavigationDeactivatedMessageArguments | Represents message arguments of NavigationDeactivated message |
| CRegisterToNavigationMessageArguments | Represents message arguments of RegisterToNavigation message |
| CUnregisterFromNavigationMessageArguments | Represents message arguments of UnregisterFromNavigation message |
| ►CPageHost | Use a PageHost node to group Page and PageHost nodes, and to manage navigation requests and transitions in a tree of Page nodes under a PageHost node |
| CNavigateNextMessageArguments | Represents message arguments of NavigateNext message |
| CNavigatePreviousMessageArguments | Represents message arguments of NavigatePrevious message |
| CNavigationFinishedMessageArguments | Represents message arguments of NavigationFinished message |
| CNavigationStartedMessageArguments | Represents message arguments of NavigationStarted message |
| ►CPageTransitionCollection | Transition collection is used to define transitions within a Page Host |
| CRuntime | Runtime class that is instantiated per page. Drives the internal state manager that is used to animate transitions |
| CTransition | Describes transition from one page to another |
| CTransitionAnimation | Entry in transition animation array |
| ►CPanManipulator | Pan input manipulator recognizes a pan gesture from the incoming touch events |
| CBaseMessageArguments | Base message arguments for pan gestures that contain movement information |
| CCanceledMessageArguments | Message arguments for pan cancel message |
| CEnteredMessageArguments | Message arguments for pan gesture entered node area message |
| CFinishedMessageArguments | Message arguments for pan gesture finished message |
| CLeftMessageArguments | Message arguments for pan gesture left node area message |
| CMovedMessageArguments | Message arguments for moved message sent during pan gesture |
| CStartedMessageArguments | Message arguments for pan gesture started message |
| CPanManipulatorComponent | PanManipulatorComponent installs a PanManipulator to a node |
| CParallelActivityHost2D | An Activity Host that can display multiple Activity nodes at a time |
| CParallelActivityHost3D | An Activity Host that can display multiple Activity nodes at a time |
| ►CParallelActivityHostConcept | This is the base class for Parallel Activity Host nodes |
| CActivityInParallelHostInfo | Stores information that identifies an Activity node under a ParallelActivityHost |
| CActivityInParallelHostPrefabLoader | Extends ActivityPrefabLoader with a specialized behavior for child Activity nodes of a ParallelExclusiveActivityHost |
| CParallelActivityHostContentHandler | Helper class used to modify the ParallelActivityHostContent of a ParallelActivityHost |
| CParallelActivityHostImpl | ParallelActivityHostConcept implementation class |
| CParallelTimeline | Kanzi animation system consists of animations and timelines: |
| CParallelTimelinePlayback | Playback control class for parallel timelines |
| ►CPatchHandler | Default patch handler |
| CKzbPatch | Applied via patchProject() |
| CProcessedState | Thread state for processed patches |
| CPropertyPatch | Applied via applyPropertyPatch() |
| CThreadState | Thread state for handling incoming patches |
| CPatchingNotificationHandler | Patching notification handler interface |
| CPerformanceInfo | HUD class allows drawing information on top of tests |
| CPerformanceInfoProperties | Configurable performance info display properties |
| ►CPinchManipulator | Pinch input manipulator recognizes the pinch gesture from the incoming touch events |
| CCanceledMessageArguments | Message that notifies about the cancellation of the pinch gesture |
| CFinishedMessageArguments | Message arguments for pinch gesture finished message. Inherits argument properties from InputManipulator::InputMessageArguments |
| CMovedMessageArguments | Message arguments for moved message sent during pan gesture. Inherits argument properties from InputManipulator::InputMessageArguments |
| CStartedMessageArguments | Message arguments for pinch gesture started message. Inherits argument properties from InputManipulator::InputMessageArguments |
| ►CPipelineStateConcept | PipelineStateConcept is a mixin that provides graphics pipeline state properties and helpers for applying them to the renderer |
| CPushState | Contains a record of applied composition state |
| CPipelineStateRenderPass | Use the Pipeline State Render Pass to set for its child render passes the depth and stencil testing, transparency, and culling |
| CPlane | The equation of a plane in 3D space is defined with a normal vector (perpendicular to that plane) and a known point on the plane |
| CPlanePlaneIntersection | Stores the intersection of two planes |
| CPlaneRayIntersection | Stores the result of an intersection between a plane and a ray |
| CPlugin | |
| CPointerEvent | The event holds a pointer event data and typically originates from a mouse or other pointing device |
| CPortal | Portal node |
| CPowerEasingFunction | Changes the value with a configurable power function using the function f(t) = t^p, where p is equal to the power parameter |
| CPrefabTemplate | A prefab template contains information that is required to create a tree of Node instances |
| CPrefabTemplateNode | A prefab template node contains information that is required to create node instances: the metaclass of the node, the (initial) property values of the node, information about the bindings and node components of the node, and the list of of child nodes |
| CPrefabView2D | Prefab view 2D node |
| CPrefabView3D | Prefab view 3D node |
| ►CPrefabViewConcept | Prefab view concept class |
| CAsynchronousLoadCompletedMessageArguments | Message arguments |
| CLoadAsynchronouslyMessageArguments | Message arguments |
| CPrefabViewConceptImpl | Base class for prefab views |
| CPreferredGPUTranslator | Converts string to preferred GPU selection type setting |
| CPresentModeTranslator | Translates present mode property from string to PresentMode |
| CPreviewTimeline | Preview timeline, |
| CPreviewTimelinePlayback | Preview timeline playback controls child timeline playbacks based on preview instructions |
| CProfilerRegistry | Profiler registry |
| CProfilingCategory | Represents the runtime state of the profiling category |
| CProfilingScopeHelper | The profiling scope helper |
| CProgressiveRenderingViewport2D | Progressive rendering viewport 2D is a viewport which splits rendering its scene across multiple frames |
| ►CPropertyAccessRange | Property access range wraps the access of properties from another range |
| CPropertyAccessRangeLocation | Location implementation for property access range |
| CPropertyAnimationTimeline | The Kanzi animation system consists of animations, which define how to animate properties, and timelines, which map animations to time and to the objects that you want to animate |
| CPropertyAnimationTimelinePlayback | Playback class for PropertyAnimationTimeline |
| CPropertyDataTypeTraits | |
| CPropertyDataTypeTraits< AbstractRangeSharedPtr > | |
| CPropertyDataTypeTraits< bool > | |
| CPropertyDataTypeTraits< ColorRGBA > | |
| CPropertyDataTypeTraits< float > | |
| CPropertyDataTypeTraits< int > | |
| CPropertyDataTypeTraits< Matrix3x3 > | |
| CPropertyDataTypeTraits< Matrix4x4 > | |
| CPropertyDataTypeTraits< ResourceSharedPtr > | |
| CPropertyDataTypeTraits< SRTValue2D > | |
| CPropertyDataTypeTraits< SRTValue3D > | |
| CPropertyDataTypeTraits< string > | |
| CPropertyDataTypeTraits< Vector2 > | |
| CPropertyDataTypeTraits< Vector3 > | |
| CPropertyDataTypeTraits< Vector4 > | |
| CPropertyDataTypeTraits< void * > | |
| CPropertyDrivenAnimationPlayer | Use Property Driven Animation Player when you want to use a property type to control a keyframe animation |
| CPropertyFieldAnimationEntry | Entry for holding information on animating property fields |
| CPropertyFieldAnimationTimeline | Kanzi animation system consists of animations and timelines: |
| CPropertyFieldAnimationTimelinePlayback | Playback control class for Property Field Animation timelines |
| CPropertyFieldTargetInterpolationTimelinePlayback | Playback for property target interpolation timeline for interpolating specific property field |
| CPropertyIsEqualFilter | Use the Property Is Equal Filter to collect 3D nodes that contain, or do not contain a specific property whose value matches a specific value |
| CPropertyIsEqualFilterRuntime | Runtime for contains property node filter |
| CPropertyListener | |
| CPropertyModifierBindingTargetRuntime | Base class for property modifier binding target runtimes |
| CPropertyObject | PropertyObject is the base class that supports setting and retrieving of property types |
| CPropertyObserver | Helper class for observing certain property in nodes |
| ►CPropertyTargetEasingInterpolator | Use a Property Target Easing Interpolator when you want to create a smooth transition between the current value of a property and a value that you set dynamically |
| CSetEnabledMessageArguments | Message arguments for the PropertyTargetEasingInterpolator::SetEnabledMessage message |
| CPropertyTargetEasingTimeline | Property Target Easing Timeline interpolates a property gradually from its old value to a new value using an easing curve each time a new value is set to the property |
| CPropertyTargetEasingTimelinePlayback | Playback for PropertyTargetEasingTimeline |
| CPropertyTargetInterpolationTimeline | Property target interpolation timeline is a timeline that gradually interpolates specified property from its old value to new one each time new value is set to the property |
| CPropertyTargetInterpolationTimelinePlayback | Playback for property target interpolation timeline |
| ►CPropertyTargetInterpolator | Use a Property Target Interpolator when you want to dynamically set the target value of a property and want to interpolate the current value to the target value over time |
| CCompletedMessageArguments | Message arguments for Completed message |
| CPropertyType | An instance of a PropertyType represents a single property type in the Kanzi property system |
| ►CPropertyType< Type, typename enable_if< is_enum< Type >::value >::type > | Specialization for PropertyType for enums. See PropertyType |
| CTraits | |
| ►CPropertyTypeDescriptor | PropertyTypeDescriptor is used internally by the property system to implement all operations required for property types that have the same data type |
| CTypedModifierEntry | |
| CTypedModifierStorage | |
| CTypedNotificationEntry | |
| ►CTypedNotificationStorage | |
| CCleanupFunctor | Functor for cleaning up stale notification entries |
| CTypedValueSource | |
| ►CPropertyTypeEditorInfo | Editor information for metadata |
| CAttributeDictionary | |
| CQnxLogger | |
| CQuadDescription | Use QuadDescription to create renderable quad geometry |
| CQuadraticEasingFunction | Changes the value based on the square of time using the function f(t) = t^2 |
| CQuarticEasingFunction | Changes the value based on the 4th order polynomial using the function f(t) = t^4 |
| CQuaternion | Quaternions represent rotation around an axis, defined by quaternion components x, y, z and w |
| CQuaternionLongerPath | Quaternion for interpolating rotation along longer path |
| CQuinticEasingFunction | Changes the value based on the 5th order polynomial using the function f(t) = t^5 |
| CRangeAccumulateBindingProcessor | Runs a binary operation for each value in a range in sequence |
| CRangeAccumulateBindingProcessorRuntime | Holds the runtime state of a RangeAccumulateBindingProcessor |
| CRangeBindingProcessor | Range binding processor is a binding processor for accessing properties from property objects in ranges |
| CRangeBindingProcessorRuntime | Holds the runtime state of a RangeBindingProcessor |
| ►CRangeConcept | RangeConcept represents a number range with an optional step |
| CCommonMessageArguments | |
| CValueChangedMessageArguments | |
| CValueChangeFinishedMessageArguments | |
| CValueChangeStartedMessageArguments | |
| CRangeConceptImpl | |
| ►CRangeIndexAnimationTimeline | Range index animation timeline represents the functionality to animate values within a range |
| CEntry | Structure holding the index and field in the range which is to be animated, along the associated animation |
| CRangeIndexAnimationTimelinePlayback | Playback control class for Range Index Animation timelines |
| CRasterStateCache | Use a Raster State Cache to look up a Kanzi graphics Raster State |
| CRay | Ray can be mathematically defined as a point (the origin of the ray in space) and a direction |
| CRayBoxIntersection | Stores the result of an intersection between a box and a ray |
| CRaytracedReflectionRenderPass | RaytracedReflectionRenderPass traces rays to compute screen-space reflections for surfaces with roughness below a threshold |
| CRaytracedShadowRenderPass | RaytracedShadowRenderPass traces rays to compute a shadow mask for a directional or point light |
| CReadOnlyDiskFile | Implements the File interface for files residing on a disk |
| CReadOnlyMemoryFile | (read-only) file interface to a block of memory |
| CRectangle | 2-dimensional integer rectangle |
| CReferenceCountScopeGuard | Reference count scope guard |
| CRelativeNodeResolver | Enables you to get the current node in relative path |
| ►CRenderbuffer | Renderbuffers provide the images that can be rendered to by attaching them to the framebuffer as color or depth stencil images |
| CCreateInfo | Renderbuffer creation parameters |
| ►CRenderEntry3D | Host container for render states for 3D rendering |
| CMorphHandles | Cached morph handles |
| CRenderEntryParameterContainer3D | Container type for returning return render entries from nodes |
| CRenderEntryParameterMapping3D | Helper class to manage render entry parameter mapping for requirements |
| CRenderEntryParameters3D | Parameters for RenderEntry3D construction |
| CRenderEntryRegistry | Registry used to keep track of DrawObjectsRenderPass objects that contain render entries |
| ►CRenderer | Kanzi legacy renderer interface |
| CRendererSettings | Settings structure for renderer construction |
| CRendererStatisticsScope | |
| ►CRenderPass | RenderPass is the base class for Kanzi render passes |
| CCameraProjectionState | CameraProjectionState manages camera projection property value sources on a render pass |
| CCameraSettings | Camera settings structure |
| ►CRenderPassArchetype | The Render Pass Archetype contains a set of Kanzi Graphics render pass objects that are all compatible |
| CAttachmentState | Per-attachment information |
| CRenderPassArchetypeCache | Use a Render Pass Archetype cache to look up an archetype of compatible render passes |
| CRenderPassPrefab | Use render pass prefabs to create render pass trees that define how Kanzi renders 3D content in your project |
| CRenderPassTemplate | Use RenderPassTemplate to instantiate a single render pass |
| CRenderPassView | Use the Render Pass View to instantiate a RenderPassPrefab |
| CRenderPropertyBindingSource | Render property binding source |
| CRenderPropertyBindingSourceRuntime | Runtime for RenderPropertyBindingSource |
| CRenderPropertyExpressionValueSource | Render property expression value source |
| CRenderPropertyExpressionValueSourceRuntime | Runtime for render property expression value source |
| ►CRenderState | Kanzi graphics render state |
| CBufferRenderValue | |
| CDrawParameters | Parameters for full-featured draw |
| CResourceSet | Creation information for a RenderResourceSet |
| CTextureRenderValue | Per texture value |
| CUniformBufferObject | Contents and upload information for an uniform buffer object |
| CRenderStatePropertyNotificationHandler | Render value updater for render state |
| CRenderValueBinding | RenderValueBinding is a binding from shaders/materials into values in RenderState |
| CRenderValueBindingTargetRuntime | Runtime for render value binding target |
| CResource | Represents the base class for all resources |
| CResourceBindingProcessor | Resource binding processor creates a resource reference that is used to resolve a string into a resource |
| CResourceBindingProcessorRuntime | Holds the runtime state of a ResourceBindingProcessor |
| CResourceBindingSource | Resource binding source |
| CResourceBindingSourceRuntime | Runtime for object property binding source |
| CResourceDictionary | A resource dictionary is a container that maps resource IDs to resources |
| CResourceDictionarySelector | A resource dictionary selector is a type of a resource dictionary that redirects resource queries to its only nested dictionary |
| CResourceID | Resource ID |
| CResourceLoaderFactory | Factory for resource loader tasks |
| CResourceLoaderThreadContext | Resource loader thread local data |
| ►CResourceManager | Use the resource manager to access and use resources in kzb files |
| CAcquireTask | Load task for a group of resources |
| CFinishingQueue | Collection of resource loading tasks that have been already been loaded by a loader thread and are waiting to be finished by the main thread |
| CLoadTask | Use this base class to implement the load tasks that load new resources |
| ►CResourceInfoSet | Use a resource information set to get visibility of the resources that are added to or removed from the ResourceManager |
| CResourceInfoEntry | Entry in the resource set |
| CResourceProfiler | The resource profiler |
| ►CResourceProfilingAcquireContext | The profiling context of resource acquirement |
| CSampler | The context sampler |
| CResourceProfilingAttributes | Container for resource profiling attributes |
| CResourceProfilingContext | The resource profiling context |
| ►CResourceProfilingContextFactory | Resource profiling context factory |
| CAbstractSampler | Abstract resource profiling context sampler |
| ►CResourceProfilingDataSample | The resource profiling data sample |
| CFactory | The resource factory |
| ►CResourceProfilingDeployContext | The profiling context of resource deployment |
| CSampler | The context sampler |
| ►CResourceProfilingLoadContext | The profiling context of resource loading |
| CSampler | The context sampler |
| CResourceProfilingLoadTask | Resource profiling wrapper for load task |
| ►CResourceProfilingMainLoopContext | The main loop resource profiling context |
| CSampler | The context sampler |
| CResourceProfilingPtreePopulator | Resource profiling ptree populator |
| CResourceReference | |
| ►CSampler | Sampler provides the sampling parameters used to sampling textures |
| CCreateInfo | Sampler create info structure |
| CSamplerCache | Cache for sampler objects |
| CScene | Scene is a 3D node that is the root node for other 3D nodes |
| CSceneAccelerationStructure | An acceleration structure contains data used by ray tracing in the scene (TLAS) |
| CSceneBuffer | Packs data into a std140 uniform buffer |
| CSceneData | Scene-level data (std140 layout) |
| CSceneGraphTimelinePlaybackContext | Helper class to resolve objects for animation timelines |
| CScopedRefCounter | Scoped reference counter, which takes an unsigned integer value as argument on construction to track |
| CScopeValue | ScopeValue template class sets a value to a variable of Type for the lifetime of the ScopeValue object, and restores the previous value of the variable when destroyed |
| ►CScreen | The screen represents the metrics of the target device and acts as the root node for the whole node tree |
| CActivateThemeMessageArguments | |
| CScrollView2D | Use the Scroll View 2D node to create an input plane to enable user input from gestures |
| CScrollView3D | Use the Scroll View 3D node to create an input plane to enable user input from gestures |
| ►CScrollViewConcept | ScrollViewConcept is the base class that provides the functionality for the ScrollView2D and ScrollView3D classes |
| CScrollDownMessageArguments | Message arguments used by the ScrollDownMessage |
| CScrolledMessageArguments | |
| CScrollEndMessageArguments | Message arguments used by the ScrollEndMessage |
| CScrollFinishedMessageArguments | |
| CScrollHomeMessageArguments | Message arguments used by the ScrollHomeMessage |
| CScrollLeftMessageArguments | Message arguments used by the ScrollLeftMessage |
| CScrollMessageArguments | |
| CScrollPageDownMessageArguments | Message arguments used by the ScrollPageDownMessage |
| CScrollPageUpMessageArguments | Message arguments used by the ScrollPageUpMessage |
| CScrollPositionMessageArguments | |
| CScrollRightMessageArguments | Message arguments used by the ScrollRightMessage |
| CScrollStartedMessageArguments | |
| CScrollTargetMessageArguments | |
| CScrollUpMessageArguments | Message arguments used by the ScrollUpMessage |
| CSetScrollMessageArguments | |
| CSetScrollTargetMessageArguments | |
| CSnapMessageArguments | |
| CSnapRequestMessageArguments | |
| CUserScrollFinishedMessageArguments | |
| CUserScrollStartedMessageArguments | |
| CZoomedMessageArguments | |
| CScrollViewConceptImpl | Implementation class for ScrollViewConcept |
| CSetPropertyAction | SetPropertyAction sets the value of a property of a target node based on: |
| ►CShaderCompiler | Provides the interface for a shader compiler that prepares the GLSL shader source code so that it conforms to the Vulkan GLSL extension (https://github.com/KhronosGroup/GLSL/blob/master/extensions/khr/GL_KHR_vulkan_glsl.txt) for use with the KzGFx library |
| CCompileResult | Result type of the compile operation |
| CShaderErrors | Shader compilation error messages |
| CShaderIncludeResult | When providing custom shader include logic, communicates the result of a shader include operation |
| CShaderSource | Shader input data for a shader stage |
| CStageResult | Shader compiler results for a single stage |
| ►CShaderProgram | ShaderProgram defines programmable vertex and fragment operations done by the GPU for a draw call |
| CAccelerationStructure | Description of a Shader Acceleration Structure |
| CBindingInfo | Binding info |
| CBufferProperty | Description of a Buffer |
| ►CCreateInfo | Struct that contains all the parameters that Kanzi needs to create a ShaderProgram |
| CShaderStage | One shader stage in source code format |
| CCreateInfoProgramBinary | ShaderProgram creation parameters for initialized from vendor specific GL program binary |
| CCreateInfoShaderSources | ShaderProgram creation parameters for initialized from shader source code strings |
| CFixedUniformFunctionInfo | Information on fixed uniform function |
| CTextureProperty | Description of a Shader Texture |
| CUniformBuffer | Description of a uniform buffer |
| CUniformProperty | Description of a Shader Uniform |
| CShaderTextureUniform | Specifies single texture uniform entry |
| CShaderVertexAttribute | ShaderVertexAttribute describes the attributes that shader program will read when executed by graphics device |
| CShadowDenoiser | Temporal shadow denoiser for ray traced shadow masks based on the Qualcomm Shadow Denoiser algorithm |
| CShadowEffect2D | Use ShadowEffect2D to apply drop- and inner-shadow post-processing effects to 2D nodes |
| CShadowEffectRenderer2D | Shadow effect renderer class |
| CSharedImmutableString | Shared immutable string container |
| CSharedLockedPtr | Represents a thread-safe read-only pointer to T |
| CSineEasingFunction | Changes the value with a sine formula |
| CSlider2D | Use the Slider 2D node as a building block for a 2D UI control that lets the application user change a numerical value using a visual indicator between a minimum and a maximum value |
| CSlider2DConceptImpl | |
| CSlider3D | Use the Slider 3D node as a building block for a 3D UI control that lets the application user change a numerical value using a visual indicator between a minimum and a maximum value |
| CSlider3DConceptImpl | |
| CSliderConcept | SliderConcept contains the trajectory ResourceID property |
| CSliderTrajectoryPresenter | |
| CSlog2VerbosityLevelTranslator | Translates verbosity level from string to Slog2VerbosityLevel type |
| CSmootherStepEasingFunction | Changes the value quickly without instant changes in velocity |
| CSmoothStepEasingFunction | Changes the value quickly without instant changes in velocity |
| CSortByShaderObjectSource | Sort by shader object source |
| CSortByShaderObjectSourceRuntime | Runtime for sort by shader object source |
| CSortByZObjectSource | Z-sorting object source |
| CSortByZObjectSourceRuntime | Runtime for z-sort object source |
| CSortObjectSource | Sort object source |
| CSortObjectSourceRuntime | Base class for sort runtime classes |
| Cspan | |
| CSpeedMeasurer | Speed measurer estimates the rate of change from a series of measurements |
| CSpline | Spline is a piecewise polynomial curve that defines a path in a 3-dimensional space |
| ►CSplitStringRange | SplitStringRange is a range that iteratively performs a string split |
| CSplitPosition | String position |
| CSplitStringRangeLocation | Location implementation for split string range |
| CSRTValue2D | A structure that describes the scale, rotation and translation transformation in 2D space |
| CSRTValue3D | A structure that describes the scale, rotation and translation transformation in 3D space |
| CSRTValue3DLongerPath | |
| CSSAOHBAOMaterial | Contains property types for the Kanzi SSAO (HBAO) material shaders |
| CStackLayout2D | Stack Layout 2D arranges its items on a line along the axis you specify in the DirectionProperty |
| CStackLayout3D | Stack Layout 3D arranges its items on a line along the axis you specify in the DirectionProperty |
| CStackLayoutConcept | Stack layout concept base class |
| CStackLayoutConceptImpl | Stack layout concept implementation base class |
| CStage | Stage instances represent a Stage in the Kanzi main loop |
| CStagingBufferUpload | Represents a staging buffer upload |
| CStandardMaterial | Contains property types of Standard material |
| CStandardPbrMaterial | Contains property types for the Kanzi Physically Based Rendering (PBR) shaders |
| CStandardPostProcessMaterial | Contains property types of Standard post-process materials |
| CStartupProfilerRegistry | The registry of startup profilers |
| ►CStateManager | State manager for managing states of nodes or application |
| CEasingArguments | Easing function arguments |
| CEnteredStateMessageArguments | Represents message arguments of EnteredState message of state manager |
| CGoToDefinedStateMessageArguments | Represents message arguments of GoToNextDefinedState message of state manager |
| CGoToNextDefinedStateMessageArguments | Represents message arguments of GoToNextDefinedState message of state manager |
| CGoToPreviousDefinedStateMessageArguments | Represents message arguments of GoToPreviousDefinedState message of state manager |
| CGoToStateMessageArguments | Represents message arguments of GoToState message of state manager |
| CLeftStateMessageArguments | Represents message arguments of LeftState message of state manager |
| CState | |
| CStateChangeMessageArguments | |
| CStateGroup | |
| CStateGroupRuntime | State group runtime |
| CStateManagerMessageArguments | Represents base message arguments of state manager messages |
| CStateManagerRuntime | |
| CStateObject | |
| CStateObjectRuntime | State object runtime |
| CStateRuntime | State runtime |
| CStateTransition | |
| CStateTransitionAnimation | |
| CTargetObject | TargetObject |
| CTransitionFinishedMessageArguments | Represents message arguments of TransitionFinished message of state manager |
| CTransitionMessageArguments | |
| CTransitionStartedMessageArguments | Represents message arguments of TransitionStarted message of state manager |
| CStepEasingFunction | Changes the value instantly |
| CStopWatch | Stop watch is a class for measuring time |
| ►CStyle | Style applying properties, node components and bindings to nodes |
| CBindingInfo | Stored info for a binding |
| CSurface | Surfaces provide images for Framebuffers where to render to |
| CSurfaceClientAPITranslator | Translates surface client API property from string to SurfaceClientAPI |
| CSuspensionManager | Manages application suspension on POSIX platforms |
| CSwapBehaviorTranslator | Translates swap behavior property from string to SwapBehavior |
| CTagFilter | Use the Tag Filter to collect 3D nodes that have a specific tag assigned |
| CTagFilterRuntime | Runtime for tag filter |
| CTargetPreviewPlugin | Target preview plugin allows Kanzi Studio to remotely apply UI scene changes to the application |
| CTaskDispatcher | Task dispatcher |
| CTemporaryDebugVisualizationList | Temporary debug visualization listing |
| CTextBlock2D | Text Block 2D displays a small amount of text in 2D |
| CTextBlock3D | Text Block 3D displays a small amount of text in 3D |
| CTextBlockConcept | Base class for the Text Block nodes that you can use to show a small amount of text in your application |
| CTextBlockConceptImpl | Implementation class for TextBlockConcept |
| ►CTextBox2D | TextBox2D provides the required overrides to handle 2D rendering and gesture handling for the 2D text input |
| CSelectionData | |
| CTextBox2DTraits | |
| CTextBox3D | TextBox3D provides the required overrides to handle 3D rendering and gesture handling for the 3D text input |
| CTextBox3DTraits | |
| ►CTextBoxConcept | Use the Text Box nodes to add single-line text input to your application |
| CCursorPositionMessageArguments | Message arguments for messages that contain the information about the position index of the cursor position |
| CDeleteSelectionMessageArguments | Message arguments for messages that delete the portion of the text that is selected |
| CEditingStateChangedMessageArguments | Message arguments for the messages about changing the editing state of a Text Box node |
| CEraseCharactersMessageArguments | Message arguments for messages that erase the characters at the cursor position |
| CInputMethodActionMessageArguments | Message arguments for the message about the input method action execution received on a Text Box node |
| CInputMethodAvailableMessageArguments | Message arguments for the InputMethodAvailableMessage and InputMethodUnavailableMessage |
| CModifyEditingStateMessageArguments | Message arguments for the messages that modify the editing state |
| CModifySelectionMessageArguments | Message arguments for the messages that modify the cursor position for a selection |
| CMoveCursorMessageArguments | Message arguments for messages that move the cursor position |
| CSelectedTextMessageArguments | Message arguments that hold the information about the selected text in the buffer of a Text Box node |
| CTextChangedMessageArguments | Message arguments for the messages about the content change of a Text Box node |
| CTextCompositionStateMessageArguments | Message arguments for the messages about the text composition state change of a Text Box node |
| CTextContentMessageArguments | Message arguments for the messages about the content of a Text Box node |
| CTextInsertionMessageArguments | Message arguments that hold the information for inserting text to a Text Box node |
| CTextRangeMessageArguments | Message arguments that hold the information for operations that target a text range, such as selecting or deleting text in a Text Box node |
| CTextBoxConceptImpl | TextBoxConceptImpl is an abstract class for implementing the Text Box node concept |
| CTextBreakIterator | |
| ►CTextConcept | TextConcept is the base class for the nodes that implement text rendering |
| CTextFormatParameters | Structure that holds the parameters that TextConceptImpl::prepareTextFormat() needs |
| CTextConceptImpl | TextConceptImpl provides the common base implementation for text rendering nodes |
| CTextEditBuffer | TextEditBuffer is a model for text input |
| CTextFormat | Text format combines the data required for text layouting and the data required for rendering the text |
| CTextInputGesture | The text input key gesture |
| CTextInputLayout | Use TextInputLayout to precalculate information on text layout properties, such as glyph directionality, width, buffer index to glyph mapping, and so on |
| ►CTextInputManipulator | The text input manipulator handles key gestures used with TextBox nodes to move the cursor, select text, and delete text, and provides the basics of text editing capabilities in Kanzi |
| CCursorMovedMessageArguments | Message arguments used by the CursorMovedMessage |
| CInputMethodActionMessageArguments | Message argument used by the InputMethodActionMessage |
| CInputMethodAvailableChangedMessageArguments | Message argument used by the InputMethodAvailableChangedMessage |
| CInputMethodsDisconnectedMessageArguments | Message argument used by the InputMethodsDisconnectedMessage |
| CInputTypeChangedMessageArguments | Message argument used by the InputTypeChangedMessage |
| CReadOnlyStateChangedMessageArguments | Message argument used by the ReadOnlyStateChangedMessage |
| CSelectionChangedMessageArguments | Message arguments used by the SelectionChangedMessage |
| CTextChangedMessageArguments | Message argument used by the TextChangedMessage |
| CTextCompositionStateMessageArguments | Message argument used by the CompositionTextChangedMessage, CompositionTextCommittedMessage and TextCompositionCanceledMessage |
| CTextLayout | Structure for layout of arbitrary number of characters for text rendering |
| ►CTextLayouter | Use the TextLayouter to create layouts for display text strings, including line breaks, bidirectional text shaping, and similar |
| CCharacterInfo | Intermediate structure for layout of a single character |
| CIntermediateLayout | Intermediate structure for the layout of the text where the characters have not yet been positioned |
| CLineInfo | Structure for holding data about text lines |
| CTextManager | Use the TextManager class to: |
| CTextResource | Text resource |
| CTextShaper | TextShaper encapsulates different shaping libraries, used by TextLayouter to perform BiDi layouting, text shaping and glyph substitution |
| CTextShaperState | Wrapper for the internal state of the TextShaper |
| ►CTexture | Textures provide images that can be used with image nodes, texture brushes and materials for use in 3D rendering or material brushes |
| CCreateInfo | Struct which contains all the parameters that are needed for texture creation |
| CCreateInfo2D | Texture creation parameters for two dimensional texture |
| CCreateInfo3D | Texture creation parameters for 3D textures |
| CCreateInfoCubemap | Texture creation parameters for cubemap texture that is initialized from six images |
| CCreateInfoCubemapRenderTarget | Use Texture::CreateInfoCubemapRenderTarget to create a Cubemap Render Target Texture resource |
| CCreateInfoHostCopy2D | Texture creation parameters for two dimensional texture that is updated from the CPU |
| CCreateInfoRenderTarget | Texture creation parameters for texture that can be used as render target for 2D nodes |
| CTextureBrush | Texture brush class |
| CTextureBrushRenderer | Texture brush renderer class |
| CTimeInterval | Interval in time specified as start and end timestamps |
| CTimeline | The Kanzi animation system consists of animations and timelines: animations define how the values of specific type change in time, and timelines map the animations to properties of objects you want to animate |
| CTimelineClock | Use TimelineClock to update a Timeline based on time |
| CTimelinePlayback | Playback object for Timelines |
| ►CTimelinePlaybackContext | Use TimelinePlaybackContext helper interface class to defines the context of an animation playback |
| CRuntimeEnvironment | Defines a runtime environment for the animation playback |
| CTimelineResource | A Resource wrapper class for animation timelines |
| CTimerTrigger | Use the TimerTrigger to execute actions at the time interval that you set with the IntervalProperty |
| CToggleButton2D | Use the Toggle Button 2D node to create a 2D UI control that the user can interact with through clicking, tapping, or pressing a keyboard key, and that has multiple toggle states |
| CToggleButton3D | Use the Toggle Button 3D node to create a 3D UI control that the user can interact with through clicking, tapping, or pressing a keyboard key, and that has multiple toggle states |
| CToggleButtonGroup2D | Toggle Button Group 2D allows users of your application to select only one option from a set of options that are mutually exclusive |
| CToggleButtonGroup3D | Toggle Button Group 3D allows users of your application to select only one option from a set of options that are mutually exclusive |
| ►CToggleButtonGroupConcept | Use a Toggle Button Group to control a collection of Toggle Buttons so that only one Toggle Button can be toggled on at a time |
| CToggleButtonGroupConceptMessageArguments | |
| CToggledMessageArguments | |
| CToggleButtonGroupConceptImpl | Implementation class for ToggleButtonGroupConcept |
| CToSourceBinding | To Source bindings are one-way bindings that have an extra source to which to write the result value |
| CToSourceBindingRuntime | Runtime for ToSourceBinding |
| ►CTouchEvent | The event holds the information about a touch event occurrence |
| CTouchPoint | Holds information about a touch point, such as a finger |
| CTouchPoint | The structure describes the attributes for a touch point or mouse hit |
| CTouchPointIdEquals | Helper predicate functor which you can use to search for a touch point within a touch point container using the identifier of a touch point |
| CTouchPointStateEquals | Helper predicate functor which you can use to search within a touch point container using the state of a touch point |
| CTracingSettings | Settings for the Tracing subsystem |
| CTrajectory | Trajectory defines a series of points following a geometrical path |
| CTrajectory2DInputHandler | |
| CTrajectory2DInputLogic | |
| CTrajectory3DInputHandler | |
| CTrajectory3DInputLogic | |
| CTrajectoryLayout2D | Trajectory Layout 2D arranges its items along a trajectory |
| CTrajectoryLayout3D | Trajectory Layout 3D arranges its items along a trajectory |
| CTrajectoryLayoutConcept | Base class for TrajectoryLayout classes |
| CTrajectoryLayoutConceptImpl | TrajectoryLayoutConceptImpl provides the common base implementation for Trajectory Layout nodes |
| CTrajectoryListBox3D | Use the Trajectory List Box 3D node to create scrollable lists of items arranged along a Trajectory |
| CTrajectoryListBoxConcept | TrajectoryListBoxConcept provides the common properties and messages for List Boxes which are using Trajectory Layout to layout items inside the Scroll View |
| CTrajectoryListBoxConceptImpl | Implementation class for TrajectoryListBoxConcept |
| CTrajectoryListBoxTraits | Template helper class which defines a Trajectory List Box traits |
| CTrigger | Trigger is the base class for defining events, conditions and actions for content-driven logic programming |
| CTriggerTemplate | TriggerTemplate is the base class for trigger templates |
| CTrimStringTranslator | Translator |
| CTrivialDeleter | Trivial deleter class that does not do anything with provided handle |
| CTrySetFocusAction | Use the TrySetFocusAction action to transfer focus to any focusable item in a node tree |
| CTwoWayBinding | Two-way binding causes changes to either the source value or the target value to automatically update the other |
| CTwoWayBindingRuntime | Runtime for two-way binding |
| CTypedManualBindingSourceRuntime | Typed runtime for manual binding source |
| CTypedManualBindingTargetRuntime | Typed runtime for manual binding target |
| CTypedMessageBindingSourceRuntime | Runtime for message binding source |
| CTypedMessageBindingTargetRuntime | Typed runtime for message binding target |
| CTypedObjectPropertyBindingSourceRuntime | Runtime for object property binding source |
| CTypedObjectPropertyExpressionValueSourceRuntime | Typed runtime for object property expression value source |
| CTypedPropertyModifierBindingTargetRuntime | Specialized binding target for property modifiers installed to objects |
| CTypedRenderPropertyBindingSourceRuntime | Runtime for render property binding source |
| CTypedRenderPropertyExpressionValueSourceRuntime | Typed runtime for render property expression value source |
| CTypedRenderStatePropertyNotificationHandler | Specialized property notification handler for render state |
| CTypedRenderStateRangePropertyNotificationHandler | Specialized notification handler for render state |
| CTypedRenderValueBindingTargetRuntime | Typed runtime for render value binding target |
| ►CTypedValueRange | TypedValueRange is a template class for holding one type of object in a range |
| CTypedValueRangeLocation | Location implementation for typed value range |
| CTypedValueSourceBindingTargetRuntime | Specialized binding target for value sources where the binding target itself is the value source |
| CTypedVariableBindingSourceRuntime | Typed runtime for variable binding source |
| CTypedVariableBindingTargetRuntime | Typed runtime for variable binding target |
| CTypedVariableExpressionValueSourceRuntime | Typed runtime for variable expression value source |
| CUnableToOpenFileException | Kanzi throws this exception when it tries to load a file that cannot be opened or does not exist |
| CUsingIntrusivePtr | Class that should be inherited by objects using intrusive_ptr |
| ►CValueAccumulatorBase | ValueAccumulatorBase is the base class for the Value Accumulator implementations for different data types |
| CPauseMessageArguments | Message arguments for the Pause message |
| CResumeMessageArguments | Message arguments for the Resume message |
| CStartMessageArguments | Message arguments for the Start message |
| CStopMessageArguments | Message arguments for the Stop message |
| CValueAccumulatorTimeline | Use ValueAccumulatorTimeline to create an animation that continuously adds the value of the input property to the target property |
| CValueAccumulatorTimelinePlayback | Playback for ValueAccumulatorTimeline |
| CValueAnimation | Interface template for value animations |
| CValueBindingSource | Constant value as binding source |
| CValueBindingSourceRuntime | Runtime for ValueBindingSource |
| CValueControlledExclusiveActivityHostConcept | Base class for the Exclusive Activity Host classes |
| ►CValueRange | ValueRange is an abstract range implementation that stores variant values |
| CValueRangeLocation | Location implementation for typed value range |
| CValueSourceBindingTargetRuntime | Base class for value source binding target runtimes |
| CVariableBindingHost | Binding variable host |
| CVariableBindingSource | Variable binding source |
| CVariableBindingSourceRuntime | Runtime for variable binding source |
| CVariableBindingTargetRuntime | Variable binding target runtime |
| CVariableExpressionValueSource | Variable expression value source |
| CVariableExpressionValueSourceRuntime | Runtime for variable expression value source |
| CVariant | Union container for manipulating an object from a heterogeneous set of types in a uniform manner |
| CVector2 | Vector with 2 floating point components: (x, y) |
| CVector3 | Vector with 3 floating point components: (x, y, z) |
| CVector4 | Vector with 4 floating point components: (x, y, z, w) |
| CVectorMap | VectorMap stores key-value pairs in an unordered vector and provides a simple find interface |
| ►CVertexAttribute | Base class for the vertex and instance attributes of mesh and shader program |
| CSemanticKey | |
| CVertexInputStateCache | Use a Vertex Input State Cache to lookup a Kanzi graphics Vertex Input State |
| CViewport2D | Use a Viewport 2D to set the size of a render target surface onto which content is projected |
| CViewport3D | Use the Viewport 3D node to render 2D nodes in 3D space |
| ►CViewRange | View over another range |
| CViewRangeLocation | Location class for indexed view range |
| CViewRangeImpl | View range internal implementation class |
| CVisitorFunction | Wraps a focus scope visitor function into a FocusScopeVisitor |
| CWakeupSignalSource | WakeupSignalSource class |
| CWatermark | Watermark |
| CWin32DebugLogger | This logger class writes log messages to the Windows debugger console |
| CWindowedGraphicsOutput | WindowedGraphicsOutput class |
| CWindowEvent | Holds window specific events |
| CWindowPlacementRequestEvent | Specialized window event with InputEvent::WindowPlacementRequest type |
| CWindowRedrawRequestEvent | Specialized window event with InputEvent::WindowRedrawRequest type |
| CWindowResizedEvent | Specialized window event with InputEvent::WindowResized type |
| CWindowResizeRequestEvent | Specialized window event with InputEvent::WindowResizeRequest type |
| CWindowsIme | |
| CWindowsImeBackend | |
| CWindowStyleTranslator | Translates windows style property from string to KzsWindowStyle |
| CWriteLogAction | Use the WriteLogAction class to attach logging functionality to a trigger |
| CWriteOnlyDiskFile | Implements the File interface for writing files to a disk |
| ►NYAML | |
| Cconvert< kanzi::ColorRGBA > | Specialization of convert<> |
| Cconvert< kanzi::Matrix3x3 > | Specialization of convert<> |
| Cconvert< kanzi::Matrix4x4 > | Specialization of convert<> |
| Cconvert< kanzi::Quaternion > | Specialization of convert<> |
| Cconvert< kanzi::SRTValue2D > | Specialization of convert<> |
| Cconvert< kanzi::SRTValue3D > | Specialization of convert<> |
| Cconvert< kanzi::Vector2 > | Specialization of convert<> |
| Cconvert< kanzi::Vector3 > | Specialization of convert<> |
| Cconvert< kanzi::Vector4 > | Specialization of convert<> |
| CAbstractBindingRuntimeWrapper | |
| CAbstractBindingWrapper | |
| CBindingProcessorWrapper | |
| CBitmapImageWrapper | |
| CBoolOut | |
| CCColorRGBA | |
| CClassPropertyDefaultValueWrapper | |
| CCMatrix3x3 | |
| CCMatrix4x4 | |
| CContext | |
| CCQuaternion | |
| CCSRTValue2D | |
| CCSRTValue3D | |
| CCVector2 | |
| CCVector3 | |
| CCVector4 | |
| CDataContextModifiedSubscriptionTokenWrapper | |
| CEditorInfoWrapper | |
| CFloatOut | |
| CGPUBuffer_CreateInfoWrapper | |
| Chash< kanzi::AbstractPropertyType > | Specialization of kanzi::hash for AbstractPropertyType |
| Chash< kanzi::ResourceID > | |
| CIntOut | |
| CIteratorWrapper | |
| CKzsDesktop | Desktop object |
| CKzsDesktopNative | |
| CKzsDisplay | Display device object |
| CKzsDisplayNative | |
| CKzsInputDevice | Input device object |
| CKzsInputDeviceNative | Native implementation of input device |
| CKzsSurface | Surface for graphics output |
| CKzsSurfaceConfiguration | Configuration data for surfaces and windows |
| CkzsSurfaceConfigurationNativeFunctions | |
| CkzsSurfaceNativeFunctions | |
| CKzsSurfaceNativeWGL | |
| CKzsSurfaceProperties | Properties for a surface |
| CKzsWindow | Kanzi window structure |
| CKzsWindowNative | Platform specific window variables |
| CLongOut | |
| CMesh_CreateInfoWrapper | |
| CMessageArgumentsWrapper | |
| CMessageSubscriptionTokenWrapper | |
| CMessageTypeWrapper | |
| CMetaclassWrapper | |
| CNativeExceptionWrapper | Used to store a native exception ptr in a foreign language |
| CNodeEffectTemplate2DWrapper | |
| CObjectReference | |
| CObjectWrapper | |
| CObjectWrapperOut | |
| CPropertyTypeWrapper | |
| CRenderPassTemplateWrapper | |
| CResourceAcquireTaskWrapper | |
| CResourceIDWrapper | |
| CShaderProgram_CreateInfoWrapper | |
| CSizeTOut | |
| CSpanByte | |
| CSplineWrapper | |
| CStringOut | |
| CStringView | |
| CStringWrapper | |
| CVariantWrapper | |
| CWglLibrary | |
| CWglPixelFormat | Stores WGL pixel formats |