| ►Nstd | |
| Ctuple_element< 0, xiiHashTableBaseConstIterator< K, V, H > > | |
| Ctuple_element< 0, xiiHashTableBaseIterator< K, V, H > > | |
| Ctuple_element< 0, xiiMapBaseConstIteratorBase< KeyType, ValueType, Comparer, REVERSE > > | |
| Ctuple_element< 0, xiiMapBaseIteratorBase< KeyType, ValueType, Comparer, REVERSE > > | |
| Ctuple_element< 1, xiiHashTableBaseConstIterator< K, V, H > > | |
| Ctuple_element< 1, xiiHashTableBaseIterator< K, V, H > > | |
| Ctuple_element< 1, xiiMapBaseConstIteratorBase< KeyType, ValueType, Comparer, REVERSE > > | |
| Ctuple_element< 1, xiiMapBaseIteratorBase< KeyType, ValueType, Comparer, REVERSE > > | |
| Ctuple_size< xiiHashTableBaseConstIterator< K, V, H > > | |
| Ctuple_size< xiiHashTableBaseIterator< K, V, H > > | |
| Ctuple_size< xiiMapBaseConstIteratorBase< KeyType, ValueType, Comparer, REVERSE > > | |
| Ctuple_size< xiiMapBaseIteratorBase< KeyType, ValueType, Comparer, REVERSE > > | |
| ►NxiiArchiveUtils | Utilities for working with xiiArchive files |
| CTOCMeta | |
| ►NxiiArrayPtrDetail | |
| CByteTypeHelper | |
| CByteTypeHelper< const U > | |
| ►NxiiDataDirectory | |
| CArchiveReaderCommon | |
| CArchiveReaderUncompressed | |
| CArchiveType | |
| CFileserveDataDirectoryReader | |
| CFileserveDataDirectoryWriter | |
| CFileserveType | A data directory type to handle access to files that are served from a network host |
| CFolderReader | Handles reading from ordinary files |
| CFolderType | A data directory type to handle access to ordinary files |
| CFolderWriter | Handles writing to ordinary files |
| ►NxiiExpression | |
| CFunctionDesc | Describes an expression function and its signature, e.g. how many input parameter it has and their type |
| CRegister | |
| CRegisterType | |
| CStreamDesc | Describes an input or output stream for a expression VM |
| ►NxiiGAL | |
| CModifiedRange | |
| ►NxiiInternal | |
| CArraySizeHelper | |
| CArraySizeHelper< T[N]> | |
| CCompileTimeMurmurHash | |
| CCompileTimeMurmurHash< N, 0 > | |
| CCompileTimeMurmurHash< N, 1 > | |
| CCompileTimeMurmurHash< N, 2 > | |
| CCompileTimeMurmurHash< N, 3 > | |
| CCompileTimeMurmurHash< N, 4 > | |
| CDeserializeHelper | |
| CEventMessageSenderHelper | |
| CHashHelperImpl | |
| CHashHelperImpl< T, true > | |
| ►CMessageHandler | |
| CImpl | |
| ►CMessageHandler< true > | |
| CImpl | |
| CMessageHandlerTraits | |
| CNewInstance | |
| CRenderDataCacheEntry | |
| ►CWorldData | |
| CConstObjectIterator | |
| CObjectIterator | |
| CReadMarker | |
| CWriteMarker | |
| CWriteObjectHelper | |
| CWriteObjectHelper< T * > | |
| CxiiAllocatorImpl | |
| CxiiAllocatorMixinReallocate | |
| CxiiAllocatorMixinReallocate< AllocationPolicy, TrackingMode, true > | |
| CxiiStaticRTTI | [internal] Helper struct for accessing static RTTI data |
| CxiiStaticRTTI< void > | |
| CxiiStaticRTTI< xiiNoBase > | |
| CxiiStaticRTTIWrapper | |
| ►NxiiLogWriter | |
| CConsole | A simple log writer that writes out log messages using printf |
| CETW | A simple log writer that outputs all log messages to the XII ETW provider |
| CHTML | A log writer that writes out log messages to an HTML file |
| CVisualStudio | A simple log writer that outputs all log messages to visual studios output window |
| ►NxiiMemoryPolicies | |
| CAlloctionMetaData | |
| CxiiAlignedAllocation | Allocation policy to support custom alignment per allocation |
| CxiiAlignedHeapAllocation | Aligned Heap memory allocation policy |
| CxiiGuardedAllocation | |
| CxiiHeapAllocation | Default heap memory allocation policy |
| CxiiProxyAllocation | This Allocation policy redirects all operations to its parent |
| CxiiStackAllocation | This allocation policy works like a stack. You can only "push" and "pop" allocations in the correct order |
| ►NxiiMinWindows | |
| CFromNativeImpl | |
| CToNativeImpl | |
| ►NxiiModelImporter2 | |
| CImporter | |
| CImporterAssimp | |
| CImporterMagicaVoxel | Importer implementation to import Source engine BSP files |
| CImporterSourceBSP | Importer implementation to import Source engine BSP files |
| CImportOptions | |
| COutputMaterial | |
| COutputTexture | |
| ►NxiiStateMachineInternal | |
| ►CCompound | Helper class to manage instance data for compound states or transitions |
| CInstanceData | |
| ►NxiiTokenParseUtils | |
| CTokenMatch | A token to be matched by the xiiTokenParseUtils::Accept overload for arrays of tokens. Can either match a token string or type. If type is xiiTokenType::Unknown, the token string will be matched |
| CArrayPtrTask | |
| CBacktrace | |
| CCompareConstChar | |
| Cconst_iterator_base | Base class for STL like random access iterators |
| Cconst_reverse_pointer_iterator | Base class for Pointer like reverse iterators |
| Cenable_if_t< sizeof(T) >=5 > > | |
| Cenable_if_t< sizeof(T)<=4 > > | |
| CeqQtAssetBrowserFolderView | Folder tree of the asset browser to allow filtering by folder |
| CExpressionHighlighter | |
| CExpressionTokenType | |
| CGameMode | |
| CgetArgument | Use getArgument<N, Args...>::Type to get the type of the Nth argument in Args |
| CgetArgument< 0, Head, Tail... > | |
| CgetArgument< _Index, Head, Tail... > | |
| CGridVertex | |
| Citerator_base | Non-const STL like iterators |
| CObjectData | |
| Cogt_mesh | |
| Cogt_mesh_rgba | |
| Cogt_mesh_vec3 | |
| Cogt_mesh_vertex | |
| Cogt_vox_group | |
| Cogt_vox_instance | |
| Cogt_vox_layer | |
| Cogt_vox_model | |
| Cogt_vox_palette | |
| Cogt_vox_rgba | |
| Cogt_vox_scene | |
| Cogt_vox_transform | |
| Cogt_voxel_meshify_context | |
| CPageDownloader | |
| CQList | |
| Creverse_pointer_iterator | Non-Const class for Pointer like reverse iterators |
| CTransformationChanges | |
| CxiiAbstractArrayProperty | The base class for a property that represents an array of values |
| CxiiAbstractConstantProperty | This is the base class for all constant properties that are stored inside the RTTI data |
| CxiiAbstractEnumerationProperty | The base class for enum and bitflags member properties |
| CxiiAbstractFunctionProperty | The base class for a property that represents a function |
| CxiiAbstractGraphBinarySerializer | |
| CxiiAbstractGraphDdlSerializer | |
| CxiiAbstractGraphDiffOperation | |
| CxiiAbstractMapProperty | The base class for a property that represents a set of values |
| CxiiAbstractMemberProperty | This is the base class for all properties that are members of a class. It provides more information about the actual type |
| CxiiAbstractMessageHandler | The base class for all message handlers that a type provides |
| CxiiAbstractObjectGraph | |
| ►CxiiAbstractObjectNode | |
| CProperty | |
| CxiiAbstractProperty | This is the base interface for all properties in the reflection system. It provides enough information to cast to the next better base class |
| CxiiAbstractSetProperty | The base class for a property that represents a set of values |
| CxiiAccessorArrayProperty | |
| CxiiAccessorMapProperty | |
| CxiiAccessorProperty | [internal] An implementation of xiiTypedMemberProperty that uses custom getter / setter functions to access a property |
| CxiiAccessorSetProperty | |
| CxiiAccessorSetProperty< Class, xiiStringView, const xiiTagSet & > | |
| CxiiAction | |
| CxiiActionContext | |
| CxiiActionDescriptor | |
| CxiiActionDescriptorHandle | Handle for a xiiAction |
| ►CxiiActionManager | Stores 'actions' (things that can be triggered from UI) |
| CEvent | |
| CxiiActionMap | Defines the structure of how actions are organized in a particular context |
| CxiiActionMapDescriptor | |
| CxiiActionMapManager | A central place for creating and retrieving action maps |
| CxiiActionScope | |
| CxiiActionType | |
| CxiiActivateRemoteViewMsgToEngine | |
| CxiiActiveDocumentChange | |
| CxiiActiveLayerChangedMsgToEngine | |
| CxiiActor | |
| CxiiActorApiService | |
| CxiiActorEvent | |
| CxiiActorManager | |
| CxiiActorPlugin | |
| CxiiActorPluginWindow | |
| CxiiActorPluginWindowOwner | |
| CxiiActorPluginWindowShared | |
| CxiiActorPluginWindowXR | XR actor plugin window base implementation. Optionally wraps a companion window and output target |
| CxiiAddObjectCommand | |
| CxiiAdobeCUBEReader | Simple implementation to read Adobe CUBE LUT files |
| CxiiAfterSaveDocumentTask | |
| CxiiAimIKComponent | Adds inverse kinematics for a single joint of an animated mesh to point towards a target |
| CxiiAlignedAllocatorWrapper | |
| CxiiAllocator | Policy based allocator implementation of the xiiAllocatorBase interface |
| ►CxiiAllocatorBase | Base class for all memory allocators |
| CStats | |
| CxiiAlphaControlPoint | |
| CxiiAlwaysVisibleComponent | Attaching this component to a game object makes the renderer consider it always visible, ie. disables culling |
| CxiiAmbientCube | |
| CxiiAmbientCubeBasis | |
| CxiiAmbientLightComponent | |
| CxiiAndroidUtils | |
| CxiiAngleTemplate | Wrapper class for a safe usage and conversions of angles |
| CxiiAnimatedMeshAssetDocument | |
| CxiiAnimatedMeshAssetDocumentGenerator | |
| CxiiAnimatedMeshAssetDocumentManager | |
| CxiiAnimatedMeshAssetProperties | |
| CxiiAnimatedMeshComponent | Instantiates a mesh that can be animated through skeletal animation |
| CxiiAnimatedMeshComponentDragDropHandler | |
| CxiiAnimatedMeshComponentManager | |
| CxiiAnimatedMeshContext | |
| CxiiAnimatedMeshViewContext | |
| CxiiAnimationClip1D | |
| CxiiAnimationClip2D | |
| CxiiAnimationClipAssetDocument | |
| CxiiAnimationClipAssetDocumentGenerator | |
| CxiiAnimationClipAssetDocumentManager | |
| CxiiAnimationClipAssetProperties | |
| CxiiAnimationClipContext | |
| CxiiAnimationClipMapping | |
| CxiiAnimationClipResource | |
| ►CxiiAnimationClipResourceDescriptor | |
| CJointInfo | |
| CKeyframeQuat | |
| CKeyframeVec3 | |
| CxiiAnimationClipViewContext | |
| CxiiAnimationControllerComponent | Evaluates a xiiAnimGraphResource and provides the result through the xiiMsgAnimationPoseUpdated |
| CxiiAnimationControllerComponentManager | |
| ►CxiiAnimationGraphAssetDocument | |
| CPinCount | |
| CxiiAnimationGraphAssetManager | |
| CxiiAnimationGraphAssetProperties | |
| CxiiAnimationGraphNodeManager | |
| CxiiAnimationGraphNodePin | |
| CxiiAnimationInvisibleUpdateRate | What to do when an animated object is not visible |
| ►CxiiAnimController | |
| CAnimClipInfo | |
| CxiiAnimGraph | |
| CxiiAnimGraphBoneWeightsInputPin | |
| CxiiAnimGraphBoneWeightsOutputPin | |
| CxiiAnimGraphBoolInputPin | |
| CxiiAnimGraphBoolOutputPin | |
| CxiiAnimGraphInputPin | |
| CxiiAnimGraphInstance | |
| CxiiAnimGraphLocalPoseInputPin | |
| CxiiAnimGraphLocalPoseMultiInputPin | |
| CxiiAnimGraphLocalPoseOutputPin | |
| CxiiAnimGraphModelPoseInputPin | |
| CxiiAnimGraphModelPoseOutputPin | |
| CxiiAnimGraphNode | Base class for all nodes in a xiiAnimGraphInstance |
| CxiiAnimGraphNumberInputPin | |
| CxiiAnimGraphNumberOutputPin | |
| CxiiAnimGraphOutputPin | |
| CxiiAnimGraphPin | |
| CxiiAnimGraphPinDataBoneWeights | |
| CxiiAnimGraphPinDataLocalTransforms | |
| CxiiAnimGraphPinDataModelTransforms | |
| CxiiAnimGraphResource | |
| CxiiAnimGraphSharedBoneWeights | |
| CxiiAnimGraphTriggerInputPin | |
| CxiiAnimGraphTriggerOutputPin | |
| CxiiAnimPoseGenerator | Low-level infrastructure to generate animation poses from animation clips and other inputs |
| CxiiAnimPoseGeneratorCommand | Base class for all pose generator commands |
| CxiiAnimPoseGeneratorCommandAimIK | Accepts a single input in model space and applies aim IK (inverse kinematics) on it. Updates the model pose in place |
| CxiiAnimPoseGeneratorCommandCombinePoses | Combines all the local space poses that are given as input into one local pose |
| CxiiAnimPoseGeneratorCommandLocalToModelPose | Accepts a single input in local space and converts it to model space |
| CxiiAnimPoseGeneratorCommandModelPose | Base class for commands that produce or update a model pose |
| CxiiAnimPoseGeneratorCommandRestPose | Returns the rest pose (also often called 'bind pose') |
| CxiiAnimPoseGeneratorCommandSampleEventTrack | Samples the event track of an animation clip but doesn't generate an animation pose |
| CxiiAnimPoseGeneratorCommandSampleTrack | Samples an animation clip at a given time and optionally also its event track |
| CxiiAnimPoseGeneratorCommandTwoBoneIK | Accepts a single input in model space and applies two-bone IK (inverse kinematics) on it. Updates the model pose in place |
| CxiiAntialiasingPass | |
| CxiiAOPass | |
| CxiiApplication | Base class to be used by applications based on XII |
| ►CxiiApplicationFileSystemConfig | |
| CDataDirConfig | |
| CxiiApplicationPanelsMenuAction | |
| ►CxiiApplicationPluginConfig | |
| CPluginConfig | |
| CxiiApplicationServices | |
| CxiiApplyNativePropertyChangesContext | The xiiApplyNativePropertyChangesContext takes care of generating guids for native pointers that match those of the xiiAbstractObjectGraph that was passed in. This allows native changes to be tracked and applied to the object graph at a later point |
| ►CxiiArchiveBuilder | Utility class to build a xiiArchive file from files/folders on disk |
| CSourceEntry | |
| CxiiArchiveEntry | Data for a single file entry in a xiiArchive file |
| CxiiArchiveLookupString | Helper class for looking up path strings in xiiArchiveTOC::FindEntry() |
| CxiiArchiveReader | A utility class for reading from xiiArchive files |
| CxiiArchiveStoredString | Helper class to store a hashed string for quick lookup in the archive TOC |
| CxiiArchiveTOC | Table-of-contents for a xiiArchive file |
| CxiiAreaDamageComponent | Used to apply damage to objects in the vicinity and push physical objects away |
| CxiiAreaDamageComponentManager | |
| CxiiArgC | |
| CxiiArgDateTime | |
| CxiiArgF | |
| CxiiArgFileSize | |
| CxiiArgHumanReadable | Formats a given number such that it will be in format [0, base){suffix} with suffix representing a power of base. Resulting numbers are output with a precision of 2 fractional digits and fractional digits are subject to rounding, so numbers at the upper boundary of [0, base) may be rounded up to the next power of base |
| CxiiArgI | |
| CxiiArgP | |
| CxiiArgSensitive | Wraps a string that may contain sensitive information, such as user file paths |
| CxiiArgU | |
| CxiiArrayBase | Base class for all array containers. Implements all the basic functionality that only requires a pointer and the element count |
| CxiiArrayMap | See xiiArrayMapBase for details |
| ►CxiiArrayMapBase | An associative container, similar to xiiMap, but all data is stored in a sorted contiguous array, which makes frequent lookups more efficient |
| CPair | |
| CxiiArrayPropertyAccessor | |
| CxiiArrayPtr | This class encapsulates an array and it's size. It is recommended to use this class instead of plain C arrays |
| CxiiAssetAction | |
| CxiiAssetActions | |
| CxiiAssetBrowserAttribute | A property attribute that indicates that the string property is actually an asset reference |
| ►CxiiAssetBrowserItemFlags | Each item in the asset browser can be multiple things at the same time as described by these flags. Retrieved via user role xiiQtAssetBrowserModel::UserRoles::ItemFlags |
| CBits | |
| CxiiAssetCurator | |
| CxiiAssetCuratorEvent | |
| ►CxiiAssetDocument | |
| CThumbnailInfo | The thumbnail info containing the hash of the file is appended to assets. The serialized size of this class can't change since it is found by seeking to the end of the file |
| ►CxiiAssetDocumentFlags | |
| CBits | |
| ►CxiiAssetDocumentGenerator | Provides functionality for importing files as asset documents |
| CImportMode | Describes one option to import an asset |
| CxiiAssetDocumentInfo | |
| CxiiAssetDocumentManager | |
| CxiiAssetDocumentTypeDescriptor | |
| CxiiAssetDragDropHandler | |
| CxiiAssetExistanceState | |
| CxiiAssetFileExtensionWhitelist | A global whitelist for file extension that may be used as certain asset types |
| CxiiAssetFileHeader | Simple class to handle asset file headers (the very first bytes in all transformed asset files) |
| CxiiAssetInfo | |
| CxiiAssetProcessor | Background asset processing is handled by this class. Creates EditorProcessor processes |
| CxiiAssetProcessorEvent | |
| CxiiAssetProcessorLog | Log for all background processing results |
| ►CxiiAssetTable | Asset table class. Persistent cache for an asset table |
| CManagerResource | |
| CxiiAssetTableWriter | Keeps track of all asset tables and their state as well as reloading modified resources |
| CxiiAtomicBool | An atomic boolean variable. This is just a wrapper around an atomic int32 for convenience |
| CxiiAtomicCompatible | General trait to check atomic compatibility (only valid integral types or enums) |
| CxiiAtomicInteger | Integer class that can be manipulated in an atomic (i.e. thread-safe) fashion |
| CxiiAtomicIntegerTraits | Custom trait to determine if a type is a valid atomic-compatible integer or has an underlying type |
| CxiiAtomicUtils | This class provides functions to do atomic operations |
| CxiiAttachmentSettings | Defines a structured color attachment setup with default values |
| CxiiAttributeDefaultStateProvider | This is the fall back default state provider which handles the default state set via the xiiDefaultAttribute on the reflected type |
| CxiiAttributeHolder | |
| CxiiBakedProbesComponent | |
| CxiiBakedProbesComponentManager | |
| CxiiBakedProbesVolumeComponent | |
| ►CxiiBakedProbesWorldModule | |
| CProbeIndexData | |
| CxiiBakingInterface | |
| CxiiBakingSettings | |
| CxiiBasisAxis | An enum that allows to select on of the six main axis (positive / negative) |
| CxiiBeamComponent | A beam component |
| ►CxiiBitfield | A template interface, that turns any array class into a bitfield |
| CConstIterator | |
| CxiiBitflags | The xiiBitflags class allows you to work with type-safe bitflags |
| CxiiBitflagsAccessorProperty | [internal] An implementation of xiiTypedEnumProperty that uses custom getter / setter functions to access a bitflags property |
| CxiiBitflagsBase | Dummy type to pass to templates and macros that expect a base type for an bitflags class |
| CxiiBitflagsMemberProperty | [internal] An implementation of xiiTypedEnumProperty that accesses the bitflags property data directly |
| CxiiBitIterator | |
| CxiiBitIteratorStorage | |
| ►CxiiBlackboard | A blackboard is a key/value store that provides OnChange events to be informed when a value changes |
| CEntry | |
| CEntryEvent | |
| CxiiBlackboardComponent | This base component represents a xiiBlackboard, which can be used to share state between multiple components and objects |
| CxiiBlackboardCondition | |
| CxiiBlackboardEntry | |
| ►CxiiBlackboardEntryFlags | Flags for entries in xiiBlackboard |
| CBits | |
| CxiiBlackboardTemplateAssetDocument | |
| CxiiBlackboardTemplateAssetDocumentManager | |
| CxiiBlackboardTemplateAssetObject | |
| CxiiBlackboardTemplateResource | Describes the initial state of a blackboard |
| CxiiBlackboardTemplateResourceDescriptor | |
| CxiiBlendPass | Blends the two inputs by the given blend factor and writes the result to output. Note that while the output format is taken from InputA, both inputs should have the same size and format |
| CxiiBlob | XiiBlob allows to store simple binary data larger than 4GB. This storage class is used by xiiImage to allow processing of large textures for example. In the current implementation the start of the allocated memory is guaranteed to be 64 byte aligned |
| CxiiBlobPtr | This class encapsulates a blob's storage and it's size. It is recommended to use this class instead of directly working on the void* of the blob |
| ►CxiiBlockStorage | |
| CConstIterator | |
| CIterator | |
| CxiiBlockStorageType | |
| CxiiBloomPass | |
| CxiiBlurPass | Blurs input and writes it to an output buffer of the same format |
| CxiiBmpFileFormat | |
| ►CxiiBoneManipulatorAdapter | Makes an array of xiiExposedBone properties editable in the viewport |
| CElementGizmo | |
| CxiiBoneManipulatorAttribute | |
| CxiiBoneWeightsAnimNode | |
| CxiiBoolToNumberAnimNode | |
| CxiiBoolToTriggerAnimNode | |
| CxiiBoundingBoxSphereTemplate | A combination of a bounding box and a bounding sphere with the same center |
| CxiiBoundingBoxTemplate | An axis-aligned bounding box implementation |
| CxiiBoundingSphereTemplate | An implementation of a bounding sphere |
| CxiiBoxGizmo | |
| CxiiBoxManipulatorAdapter | |
| CxiiBoxManipulatorAttribute | |
| CxiiBoxReflectionProbeComponent | Box reflection probe component |
| CxiiBoxReflectionProbeComponentManager | |
| CxiiBoxReflectionProbeVisualizerAdapter | |
| CxiiBoxReflectionProbeVisualizerAttribute | A special visualizer attribute for box reflection probes |
| CxiiBoxVisualizerAdapter | |
| CxiiBoxVisualizerAttribute | |
| CxiiButtonAction | The standard button action |
| CxiiCallbackResult | Enum values for success and failure. To be used by functions as return values mostly, instead of bool |
| CxiiCamera | A camera class that stores the orientation and some basic camera settings |
| CxiiCameraComponent | |
| CxiiCameraComponentManager | |
| CxiiCameraMode | Specifies in which mode this camera is configured |
| CxiiCameraMoveContext | |
| CxiiCameraShakeComponent | This component is used to apply a shaking effect to the game object that it is attached to |
| CxiiCameraShakeVolumeComponent | Base class for components that define volumes in which a camera shake effect shall be applied |
| CxiiCameraShakeVolumeSphereComponent | A spherical volume in which a camera shake will be applied |
| CxiiCameraSpeedSliderAction | |
| CxiiCameraUsageHint | Usage hint of a camera/view |
| CxiiCameraVisualizerAdapter | |
| CxiiCameraVisualizerAttribute | |
| CxiiCapsuleGizmo | |
| CxiiCapsuleManipulatorAdapter | |
| CxiiCapsuleManipulatorAttribute | |
| CxiiCapsuleVisualizerAdapter | |
| CxiiCapsuleVisualizerAttribute | |
| CxiiCategoryAction | |
| CxiiCategoryAttribute | Used to categorize types (e.g. add component menu) |
| CxiiChangeCVarMsgToEngine | |
| CxiiCharacterControllerComponent | Base class for implementations of a character controller |
| CxiiCheckBlackboardBoolAnimNode | |
| ►CxiiChunkStreamReader | Reader for the chunk format that xiiChunkStreamWriter writes |
| CChunkInfo | Describes the state of the current chunk |
| CxiiChunkStreamWriter | A stream writer that separates data into 'chunks', which act like sub-streams |
| CxiiClampValueAttribute | A property attribute that allows to define min and max values for the UI. Min or max may be set to an invalid variant to indicate unbounded values in one direction |
| CxiiCleanType | |
| CxiiCleanType2 | |
| CxiiCleanType2< xiiBitflags< T > > | |
| CxiiCleanType2< xiiEnum< T > > | |
| CxiiCleanType< const char * > | |
| CxiiClickGizmo | The click gizmo displays a simple shape that can be clicked |
| CxiiClipSpaceDepthRange | Describes for which depth range a projection matrix is constructed |
| CxiiClipSpaceYMode | Specifies whether a projection matrix should flip the result along the Y axis or not |
| ►CxiiClock | A clock that can be speed up, slowed down, paused, etc. Useful for updating game logic, rendering, etc |
| CEventData | The data that is sent through the event interface |
| CxiiClothSheetComponent | Simulates a rectangular piece of cloth |
| CxiiClothSheetComponentManager | |
| ►CxiiClothSheetFlags | Flags for how a piece of cloth should be simulated |
| CBits | |
| CxiiClothSheetRenderData | |
| CxiiClothSheetRenderer | |
| ►CxiiClothSimulator | A simple simulator for swinging and hanging cloth |
| CNode | |
| CxiiClusteredDataCPU | |
| CxiiClusteredDataExtractor | |
| CxiiClusteredDataGPU | |
| CxiiClusteredDataProvider | |
| CxiiCodeEditorPreferences | |
| CxiiCollectionAssetData | |
| CxiiCollectionAssetDocument | |
| CxiiCollectionAssetDocumentManager | |
| CxiiCollectionAssetEntry | |
| CxiiCollectionComponent | A xiiCollectionComponent references a xiiCollectionResource and triggers resource preloading when needed |
| CxiiCollectionEntry | Represents one resource to load / preload through a xiiCollectionResource |
| CxiiCollectionResource | A xiiCollectionResource is used to tell the engine about resources that it should preload in the background |
| CxiiCollectionResourceDescriptor | Describes a full xiiCollectionResource, ie. lists all the resources that the collection contains |
| CxiiCollisionFilterConfig | A 32x32 matrix of named filters that can be configured to enable or disable collisions |
| CxiiColor | XiiColor represents an RGBA color in linear color space. Values are stored as float, allowing HDR values and full precision color modifications |
| CxiiColorAnimationComponent | Samples a color gradient and sends a xiiMsgSetColor to the object it is attached to |
| CxiiColorAttribute | Used to colorize types |
| CxiiColorBaseUB | A 8bit per channel color storage format with undefined encoding. It is up to the user to reinterpret as a gamma or linear space color |
| CxiiColorControlPoint | |
| CxiiColorGammaUB | A 8bit per channel unsigned normalized (values interpreted as 0-1) color storage format that represents colors in gamma space |
| ►CxiiColorGradient | A color curve for animating colors |
| CAlphaCP | Alpha control point |
| CColorCP | Color control point. Stores red, green and blue in gamma space |
| CIntensityCP | Intensity control point. Used to scale rgb for high-dynamic range values |
| CxiiColorGradientAssetData | |
| CxiiColorGradientAssetDocument | |
| CxiiColorGradientAssetDocumentManager | |
| CxiiColorGradientResource | A resource that stores a single color gradient. The data is stored in the descriptor |
| CxiiColorGradientResourceDescriptor | |
| CxiiColorLinear16f | A 16bit per channel float color storage format |
| CxiiColorLinearUB | A 8bit per channel unsigned normalized (values interpreted as 0-1) color storage format that represents colors in linear space |
| CxiiColorPropertyAnimEntry | |
| CxiiColorScheme | A color scheme based on https://github.com/yeun/open-color version 1.9.1 |
| CxiiCommand | Interface for a command |
| ►CxiiCommandHistory | Stores the undo / redo stacks of transactions done on a document |
| CStorage | |
| CxiiCommandHistoryAction | |
| CxiiCommandHistoryActions | |
| CxiiCommandHistoryEvent | |
| CxiiCommandInterpreter | |
| CxiiCommandInterpreterState | |
| CxiiCommandLineOption | XiiCommandLineOption (and derived types) are used to define options that the application supports |
| CxiiCommandLineOptionBool | This command line option exposes simple on/off switches |
| CxiiCommandLineOptionDoc | XiiCommandLineOptionDoc can be used to document a command line option whose logic might be more complex than what the other option types provide |
| ►CxiiCommandLineOptionEnum | An 'enum' option is a string option that only allows certain phrases ('keys') |
| CEnumKeyValue | |
| CxiiCommandLineOptionFloat | This command line option exposes float values, optionally with a min/max range |
| CxiiCommandLineOptionInt | This command line option exposes integer values, optionally with a min/max range |
| CxiiCommandLineOptionPath | This command line option exposes absolute paths. If the user provides a relative path, it will be concatenated with the current working directory |
| CxiiCommandLineOptionString | This command line option exposes simple string values |
| CxiiCommandLineUtils | This is a helper class to parse command lines |
| CxiiCommandTransaction | |
| CxiiCommentComponent | This component is for adding notes to objects in a scene |
| CxiiCommonAssetAction | |
| CxiiCommonAssetActions | |
| CxiiCommonAssetUiState | Frequently needed asset document states, to prevent code duplication |
| CxiiCompareBlackboardNumberAnimNode | |
| CxiiCompareDataDirPath | Comparator that first sort case-insensitive and then case-sensitive if necessary for a unique ordering |
| CxiiCompareHelper | A comparer object is used in sorting algorithms to compare to objects of the same type |
| CxiiCompareHelper< xiiHybridString< Size > > | |
| CxiiCompareNumberAnimNode | |
| CxiiCompareString_NoCase | |
| CxiiComparisonOperator | An enum that represents the operator of a comparison |
| CxiiCompiler | |
| CxiiCompilerPreferences | |
| CxiiComponent | Base class of all component types |
| CxiiComponent_ScriptBaseClassFunctions | |
| CxiiComponentDragDropHandler | |
| CxiiComponentHandle | A handle to a component |
| CxiiComponentId | Internal component id used by xiiComponentHandle |
| CxiiComponentInitBatchHandle | |
| CxiiComponentManager | |
| CxiiComponentManagerBase | Base class for all component managers. Do not derive directly from this class, but derive from xiiComponentManager instead |
| CxiiComponentManagerSimple | Simple component manager implementation that calls an update method on all components every frame |
| CxiiComponentMode | Specifies the mode of a component. Dynamic components may change an object's transform, static components must not |
| CxiiComponentUpdateType | |
| CxiiComputePipelinePass | |
| CxiiConditionalLock | Manages a lock (e.g. a mutex) and ensures that it is properly released as the lock object goes out of scope. The lock/unlock will only be done if the boolean condition is satisfied at scope creation time |
| CxiiConditionToCompileTimeBool | Converts a bool condition to CompileTimeTrue/FalseType |
| CxiiConditionToCompileTimeBool< true > | |
| CxiiConditionVariable | Condition variables are used to put threads to sleep and wake them up upon certain events |
| CxiiConeAngleGizmo | |
| CxiiConeAngleManipulatorAdapter | |
| CxiiConeAngleManipulatorAttribute | |
| CxiiConeLengthGizmo | |
| CxiiConeLengthManipulatorAdapter | |
| CxiiConeLengthManipulatorAttribute | |
| CxiiConeVisualizerAdapter | |
| CxiiConeVisualizerAttribute | |
| CxiiConfigFileResource | This resource loads config files containing key/value pairs |
| ►CxiiConfigFileResourceLoader | |
| CLoadedData | |
| CxiiConnection | |
| CxiiConnectNodePinsCommand | |
| CxiiConsole | |
| CxiiConsoleCmdMsgToEngine | |
| CxiiConsoleCmdResultMsgToEditor | |
| CxiiConsoleEvent | The event data that is broadcast by the console |
| CxiiConsoleFunction | Implements the functionality of xiiConsoleFunctionBase for functions with different parameter types. See xiiConsoleFunctionBase for more details |
| CxiiConsoleFunction< R(XII_LIST(P, ARG_COUNT))> | |
| CxiiConsoleFunctionBase | Base class for all types of xiiConsoleFunction, represents functions to be exposed to xiiConsole |
| CxiiConsoleString | |
| CxiiConstantProperty | [internal] An implementation of xiiTypedConstantProperty that accesses the property data directly |
| CxiiConstructorFunctionProperty | |
| CxiiContainerAttribute | Sets the allowed actions on a container |
| CxiiContainerElementMetaStateEvent | Event that is broadcast whenever information about how to present elements in a container is required |
| CxiiContainerSubTypeResolver | Template that allows to probe a container for its element type |
| CxiiContainerSubTypeResolver< xiiArrayPtr< T > > | |
| CxiiContainerSubTypeResolver< xiiDeque< T > > | |
| CxiiContainerSubTypeResolver< xiiDynamicArray< T > > | |
| CxiiContainerSubTypeResolver< xiiHashSet< T > > | |
| CxiiContainerSubTypeResolver< xiiHashTable< K, T > > | |
| CxiiContainerSubTypeResolver< xiiHybridArray< T, Size > > | |
| CxiiContainerSubTypeResolver< xiiMap< K, T > > | |
| CxiiContainerSubTypeResolver< xiiSet< T > > | |
| CxiiContainerSubTypeResolver< xiiSmallArray< T, Size > > | |
| CxiiContainerSubTypeResolver< xiiStaticArray< T, Size > > | |
| CxiiContainerSubTypeResolver< xiiTagSetTemplate< T > > | |
| CxiiContainerWidgetAttribute | Derive from this class if you want to define an attribute that replaces the property widget of containers |
| CxiiContiguousMemoryStreamStorage | |
| CxiiControllerInput | |
| CxiiControllerInputAnimNode | |
| CxiiConversionTest | Static Conversion Test |
| CxiiConversionTest< T, T > | Specialization for above Type |
| ►CxiiConvexHullGenerator | Computes convex hulls for 3D meshes |
| CFace | |
| CxiiCoordinateSystem | |
| CxiiCoordinateSystemConversion | Helper class to convert between two xiiCoordinateSystem spaces |
| CxiiCoordinateSystemProvider | |
| CxiiCopyPipelinePass | |
| CxiiCopyTexturePass | |
| ►CxiiCppProject | |
| CMachineSpecificCompilerPaths | |
| CxiiCppSettings | |
| CxiiCpuFeatures | Flags that tell you which SIMD features are available on this processor / OS |
| CxiiCpuMeshResource | |
| CxiiCrashHandler | Helper class to manage the top level exception handler |
| ►CxiiCrashHandler_WriteMiniDump | A default implementation of xiiCrashHandler that tries to write a mini-dump and prints the callstack |
| ►CPathFlags | |
| CBits | |
| CxiiCreateThumbnailMsgToEditor | |
| CxiiCreateThumbnailMsgToEngine | |
| CxiiCreatureCrawlComponent | |
| CxiiCreatureLeg | |
| CxiiCuratorMutex | Custom mutex that allows to profile the time in the curator lock |
| ►CxiiCurve1D | A 1D curve for animating a single value over time |
| CControlPoint | Stores position and tangents to control spline interpolation |
| CxiiCurve1DAssetDocument | |
| CxiiCurve1DAssetDocumentManager | |
| CxiiCurve1DResource | A resource that stores 1D curves. The curves are stored in the descriptor |
| CxiiCurve1DResourceDescriptor | A curve resource can contain more than one curve, but all of the same type |
| CxiiCurveControlPointData | |
| CxiiCurveExtentsAttribute | |
| CxiiCurveGroupData | |
| CxiiCurveTangentMode | |
| CxiiCustomData | A base class for user-defined data assets |
| CxiiCustomDataAssetDocument | |
| CxiiCustomDataAssetDocumentManager | |
| CxiiCustomDataAssetProperties | |
| CxiiCustomDataResource | Template resource type for sub-classed xiiCustomData types |
| CxiiCustomDataResourceBase | Base class for resources that represent different implementations of xiiCustomData |
| CxiiCustomMeshComponent | This component is used to render custom geometry |
| CxiiCustomMeshRenderData | Temporary data used to feed the xiiCustomMeshRenderer |
| CxiiCustomMeshRenderer | A renderer that handles all xiiCustomMeshRenderData |
| CxiiCVar | CVars are global variables that are used for configuring the engine |
| CxiiCVarEvent | The data that is broadcast whenever a cvar is changed |
| ►CxiiCVarFlags | The flags that can be used on a xiiCVar |
| CBits | |
| CxiiCVarMsgToEditor | |
| CxiiCVarType | Describes of which type a CVar is. Use that info to cast a xiiCVar* to the proper derived class |
| CxiiCVarValue | Each CVar stores several values internally. The 'Current' value is the most important one |
| CxiiCVarWidgetData | Data used by xiiQtCVarWidget to represent CVar states |
| CxiiCylinderVisualizerAdapter | |
| CxiiCylinderVisualizerAttribute | |
| CxiiDataBlock | This struct represents a block of type T, typically 4kb |
| CxiiDataDirectoryInfo | |
| CxiiDataDirectoryReader | A base class for readers that handle reading from a (virtual) file inside a data directory |
| CxiiDataDirectoryReaderWriterBase | This is the base class for all data directory readers/writers |
| CxiiDataDirectoryType | The base class for all data directory types |
| CxiiDataDirectoryWriter | A base class for writers that handle writing to a (virtual) file inside a data directory |
| CxiiDataDirPath | A reference to a file or folder inside a data directory |
| CxiiDataTransfer | A 'data transfer' is a blob of data that an application can send to connected tools such as xiiInspector upon request |
| CxiiDataTransferObject | A small wrapper class around a xiiTelemetryMessage for sending a 'data transfer'. See xiiDataTransfer for more details |
| CxiiDateTime | Can be used to convert xiiTimestamp into a human readable form |
| CxiiDdsFileFormat | |
| CxiiDebugRenderer | Draws simple shapes into the scene or view |
| CxiiDebugRendererContext | Used in xiiDebugRenderer to determine where debug geometry should be rendered |
| CxiiDebugRendererLine | |
| CxiiDebugRendererTexturedTriangle | |
| CxiiDebugRendererTriangle | |
| CxiiDebugTextComponent | This component prints debug text at the owner object's position |
| CxiiDebugTextHAlign | Horizontal alignment of debug text |
| CxiiDebugTextPlacement | Screen placement of debug text |
| CxiiDebugTextVAlign | Vertical alignment of debug text |
| CxiiDecalAssetDocument | |
| CxiiDecalAssetDocumentGenerator | |
| CxiiDecalAssetDocumentManager | |
| CxiiDecalAssetProperties | |
| CxiiDecalAtlasResource | |
| CxiiDecalAtlasResourceDescriptor | |
| CxiiDecalComponent | |
| CxiiDecalComponentDragDropHandler | |
| CxiiDecalComponentManager | |
| CxiiDecalContext | |
| CxiiDecalMode | |
| CxiiDecalRenderData | |
| CxiiDecalResource | |
| CxiiDecalResourceDescriptor | |
| ►CxiiDecalResourceLoader | |
| CLoadedData | |
| CxiiDecalViewContext | |
| CxiiDeduplicationReadContext | Serialization Context that reads de-duplicated objects from a stream and restores the pointers |
| CxiiDeduplicationWriteContext | Serialization Context that de-duplicates objects when writing to a stream. Duplicated objects are identified by their address and only the first occurrence is written to the stream while all subsequence occurrences are just written as an index |
| CxiiDefaultAllocatorWrapper | |
| CxiiDefaultContainerState | Object used to query and revert to the default state of all elements of a container of an object |
| CxiiDefaultExpressionFunctions | |
| CxiiDefaultMemoryStreamStorage | The default implementation for memory stream storage |
| CxiiDefaultObjectState | Object used to query and revert to the default state of all properties of an object |
| CxiiDefaultRenderDataCategories | |
| ►CxiiDefaultSamplerFlags | |
| CBits | |
| CxiiDefaultSpatialDataCategories | |
| CxiiDefaultState | Registry for all xiiDefaultStateProvider factory functions |
| CxiiDefaultStateProvider | Interface for querying and restoring the default state of objects and containers |
| CxiiDefaultTimeStepSmoothing | Implements a simple time step smoothing algorithm |
| CxiiDefaultValueAttribute | Sets the default value of the property |
| CxiiDeferredFileWriter | A file writer that caches all written data and only opens and writes to the output file when everything is finished. Useful to ensure that only complete files are written, or nothing at all, in case of a crash |
| CxiiDelegate | A generic delegate class which supports static functions and member functions |
| ►CxiiDelegateBase | Base class for xiiDelegate |
| CInstancePtr | |
| CxiiDelegateTask | A simple task implementation that calls a delegate function |
| CxiiDelegateTask< void > | |
| CxiiDependencyFile | This class represents a set of files of which one wants to know when any one of them changes |
| ►CxiiDependencyFlags | Defines how a reference set by xiiFileBrowserAttribute and xiiAssetBrowserAttribute is treated |
| CBits | |
| CxiiDepthOnlyPass | A render pass that renders into a depth target only |
| CxiiDepthStencilSettings | Defines a structured depth-stencil attachment setup with default values |
| CxiiDeque | |
| CxiiDequeBase | A double ended queue container |
| CxiiDeviceTrackingComponent | Tracks the position of a XR device and applies it to the owner |
| ►CxiiDGMLGraph | This class encapsulates building a DGML compatible graph |
| CConnection | |
| CNode | |
| CNodeDesc | |
| CPropertyType | |
| CPropertyValue | |
| CxiiDGMLGraphCreator | This class encapsulates creating graphs from various core engine structures (like the game object graph etc.) |
| CxiiDGMLGraphWriter | This class encapsulates the output of DGML compatible graphs to files and streams |
| CxiiDiffOperation | |
| CxiiDirectionalLightComponent | The standard directional light component. This component represents directional lights |
| CxiiDirectionalLightRenderData | The render data object for directional lights |
| CxiiDirectionVisualizerAdapter | |
| CxiiDirectionVisualizerAttribute | |
| CxiiDirectoryWatcherImpl | |
| CxiiDisconnectNodePinsCommand | |
| ►CxiiDocument | |
| CPasteInfo | |
| CxiiDocumentAction | Standard document actions |
| CxiiDocumentActions | |
| CxiiDocumentClearMsgToEngine | Used to reset the engine side to an empty document before sending the full document state over |
| CxiiDocumentConfigMsgToEngine | For very simple uses cases where a custom message would be too much |
| CxiiDocumentEvent | |
| ►CxiiDocumentFlags | |
| CBits | |
| CxiiDocumentInfo | |
| ►CxiiDocumentManager | |
| CEvent | |
| CRequest | |
| ►CxiiDocumentNodeManager | |
| CNodeInternal | |
| CxiiDocumentNodeManagerEvent | |
| CxiiDocumentObject | |
| CxiiDocumentObject_ConnectionBase | Base class for all node connections. Derive from this class and overwrite xiiDocumentNodeManager::GetConnectionType if you need custom properties for connections |
| CxiiDocumentObjectConverterReader | |
| CxiiDocumentObjectConverterWriter | Writes the state of a xiiDocumentObject to an abstract graph |
| CxiiDocumentObjectEvent | Used by xiiDocumentObjectManager::m_ObjectEvents |
| ►CxiiDocumentObjectManager | Represents to content of a document. Every document has exactly one root object under which all objects need to be parented. The default root object is xiiDocumentRoot |
| CStorage | |
| CxiiDocumentObjectMetaData | |
| CxiiDocumentObjectMirror | |
| CxiiDocumentObjectPropertyEvent | Used by xiiDocumentObjectManager::m_PropertyEvents |
| CxiiDocumentObjectStructureEvent | Used by xiiDocumentObjectManager::m_StructureEvents |
| CxiiDocumentObjectVisitor | Implements visitor pattern for content of the document object manager |
| CxiiDocumentOpenMsgToEngine | |
| CxiiDocumentOpenResponseMsgToEditor | |
| CxiiDocumentRegistry | Tracks existing and active xiiDocument |
| CxiiDocumentRoot | Standard root object for most documents. m_RootObjects stores what is in the document and m_TempObjects stores transient data used during editing which is not part of the document |
| CxiiDocumentRootObject | Implementation detail of xiiDocumentObjectManager |
| CxiiDocumentStorageObject | |
| CxiiDocumentTypeDescriptor | |
| CxiiDocumentUtils | |
| CxiiDosDevicePath | Converts an absolute path to a 'DOS device path' |
| CxiiDoubleBufferedStackAllocator | A double buffered stack allocator |
| CxiiDragDropConfig | After a xiiDragDropHandler has been chosen to handle an operation, it is queried once to fill out an instance of this type (or an extended derived type) to enable configuring how xiiDragDropInfo is computed by the target |
| CxiiDragDropHandler | |
| CxiiDragDropInfo | This type is used to provide xiiDragDropHandler instances with all the important information for a drag & drop target |
| CxiiDragToPositionGizmo | |
| CxiiDragToPositionGizmoEditTool | |
| CxiiDrawBoxGizmo | |
| CxiiDummyXR | |
| CxiiDummyXRInput | |
| CxiiDuplicateObjectsCommand | |
| CxiiDynamicActionAndMenuAction | An action that is displayed as a tool button that is clickable but also has a sub-menu that can be opened for selecting a different action |
| CxiiDynamicArray | |
| CxiiDynamicArrayBase | Implementation of a dynamically growing array |
| CxiiDynamicBitflags | Stores the valid values and names for 'dynamic' bitflags |
| CxiiDynamicBitflagsAttribute | Can be used on integer properties to display them as bitflags. The valid bitflags and their names may change at runtime |
| CxiiDynamicDefaultStateProvider | Retrieves the dynamic default state of an object or container attributed with xiiDynamicDefaultValueAttribute from an asset's meta data |
| CxiiDynamicDefaultValueAttribute | Add this attribute to an embedded class or container property to make it retrieve its default values from a dynamic meta info object on an asset |
| CxiiDynamicEnum | Stores the valid values and names for 'dynamic' enums |
| CxiiDynamicEnumAttribute | Can be used on integer properties to display them as enums. The valid enum values and their names may change at runtime |
| ►CxiiDynamicMenuAction | A menu action whose content is determined when opening the menu |
| ►CItem | |
| ►CItemFlags | |
| CBits | |
| CxiiDynamicMeshBufferResource | |
| CxiiDynamicMeshBufferResourceDescriptor | |
| CxiiDynamicMeshVertex | |
| CxiiDynamicOctree | A loose Octree implementation that is very lightweight on RAM |
| CxiiDynamicPinAttribute | Used to mark an array or (unsigned)int property as source for dynamic pin generation on nodes |
| CxiiDynamicQuadtree | A loose Quadtree implementation that is very lightweight on RAM |
| CxiiDynamicStringEnum | Stores the valid values and names for 'dynamic' enums |
| CxiiDynamicStringEnumAttribute | Can be used on string properties to display them as enums. The valid enum values and their names may change at runtime |
| CxiiDynamicStringEnumMsgToEditor | |
| ►CxiiDynamicTree | |
| CxiiMultiMapKey | |
| CxiiObjectData | |
| CxiiEasingFunction | Available Procedural Curve Generators |
| CxiiEditableSkeleton | |
| CxiiEditableSkeletonBoneCollider | |
| CxiiEditableSkeletonBoneShape | |
| CxiiEditableSkeletonJoint | |
| CxiiEditAction | |
| CxiiEditActions | |
| CxiiEditorAppEvent | |
| CxiiEditorEngineConnection | |
| CxiiEditorEngineDocumentMsg | Base class for all messages that are tied to some document |
| CxiiEditorEngineLoopAnimationMsg | |
| CxiiEditorEngineMsg | Base class for all messages between editor and engine that are not bound to any document |
| CxiiEditorEngineProcessApp | |
| ►CxiiEditorEngineProcessConnection | |
| CEvent | |
| CxiiEditorEngineRestartSimulationMsg | |
| CxiiEditorEngineSetMaterialsMsg | |
| CxiiEditorEngineSyncObject | |
| CxiiEditorEngineSyncObjectMsg | |
| CxiiEditorEngineViewMsg | |
| CxiiEditorGridExtractor | |
| CxiiEditorGuidEngineHandleMap | |
| CxiiEditorInputContext | |
| CxiiEditorPreferencesUser | Stores editor specific preferences for the current user |
| CxiiEditorProcessCommunicationChannel | |
| CxiiEditorProcessRemoteCommunicationChannel | |
| CxiiEditorProcessViewWindow | Represents the window inside the editor process, into which the engine process renders |
| CxiiEditorSelectedObjectsExtractor | |
| CxiiEditorShapeIconsExtractor | |
| CxiiEndianHelper | Collection of helper methods when working with endianess "problems" |
| CxiiEngineGizmoHandle | |
| CxiiEngineProcessCommunicationChannel | |
| CxiiEngineProcessDocumentContext | A document context is the counter part to an editor document on the engine side |
| ►CxiiEngineProcessDocumentContextFlags | |
| CBits | |
| CxiiEngineProcessGameApplication | |
| CxiiEngineProcessViewContext | Represents the view/window on the engine process side, holds all data necessary for rendering |
| CxiiEngineViewConfig | |
| CxiiEngineViewLightSettings | |
| CxiiEngineViewLightSettingsEvent | |
| CxiiEngineViewPreferences | |
| CxiiEngineWindowEvent | |
| CxiiEntityMsgToEngine | |
| CxiiEnum | A custom enum implementation that allows to define the underlying storage type to control its memory footprint |
| CxiiEnumAccessorProperty | [internal] An implementation of xiiTypedEnumProperty that uses custom getter / setter functions to access an enum property |
| CxiiEnumBase | Dummy type to pass to templates and macros that expect a base type for an enum class |
| CxiiEnumerable | Base class to add the ability to another class to enumerate all active instance of it, across DLL boundaries |
| CxiiEnumerationMenuAction | A menu that lists all values of an enum type |
| CxiiEnumMemberProperty | [internal] An implementation of xiiTypedEnumProperty that accesses the enum property data directly |
| CxiiEnumUnderlyingType | Helper trait to determine if a type is an enum and provide its underlying type |
| CxiiEnumUnderlyingType< T, std::enable_if_t< std::is_enum_v< T > > > | |
| CxiiEnvironmentVariableUtils | This is a helper class to interact with environment variables |
| CxiiEvent | |
| ►CxiiEventBase | This class propagates event information to registered event handlers |
| CUnsubscriber | An object that can be passed to xiiEvent::AddEventHandler to store the subscription information and automatically remove the event handler upon destruction |
| CxiiEventMessage | Base class for all messages that are sent as 'events' |
| CxiiEventMessageHandlerComponent | Base class for components that want to handle 'event messages' |
| CxiiEventMessageSender | A message sender that sends all messages to the next component derived from xiiEventMessageHandlerComponent up in the hierarchy starting with the given search object. If none is found the message is sent to all components registered as global event message handler. The receiver is cached after the first send/post call |
| CxiiEventMsgSetPowerInput | This event is posted by xiiPowerConnectorComponent whenever the power input on a connector changes |
| CxiiEventSet | |
| CxiiEventTrack | An event track is a time line that contains named events |
| CxiiEventTrackControlPointData | |
| CxiiEventTrackData | |
| CxiiExcludeFromScript | Attribute for types that should not be exposed to the scripting framework |
| CxiiExportDocumentMsgToEditor | |
| CxiiExportDocumentMsgToEngine | |
| CxiiExportSceneGeometryMsgToEngine | |
| CxiiExposeColorAlphaAttribute | A property attribute that indicates that the alpha channel of a xiiColorGammaUB or xiiColor should be exposed in the UI |
| CxiiExposedBone | |
| CxiiExposedDocumentObjectPropertiesMsgToEngine | |
| CxiiExposedParameter | |
| CxiiExposedParameterCommandAccessor | |
| CxiiExposedParameters | |
| CxiiExposedParametersAttribute | Add this attribute to a variant map property to make it map to the exposed parameters of an asset. For this, the member property name of the asset reference needs to be passed in. The exposed parameters of the currently set asset on that property will be used as the source |
| CxiiExposedParametersDefaultStateProvider | Default state provider handling variant maps with the xiiExposedParametersAttribute set. Reflects the default value defined in the xiiExposedParameter |
| CxiiExposedParametersTypeRegistry | Lazily converts xiiExposedParameters into phantom types. Call GetExposedParametersType to create a type for a sub-asset ID |
| CxiiExposedPrefabParameterDesc | |
| CxiiExposedSceneProperty | |
| ►CxiiExpressionAST | |
| CBinaryOperator | |
| CConstant | |
| CConstructorCall | |
| CDataType | |
| CFunctionCall | |
| CInput | |
| CNode | |
| CNodeType | |
| COutput | |
| CSwizzle | |
| CTernaryOperator | |
| CUnaryOperator | |
| CVectorComponent | |
| ►CxiiExpressionByteCode | |
| COpCode | |
| CxiiExpressionCompiler | |
| CxiiExpressionFunction | Describes an external function that can be called in expressions. These functions need to be state-less and thread-safe |
| ►CxiiExpressionParser | |
| COptions | |
| ►CxiiExpressionVM | |
| ►CFlags | |
| CBits | |
| CxiiExpressionWidgetAttribute | Add this attribute a string property that should be interpreted as expression source |
| CxiiExternalFileBrowserAttribute | Indicates that the string property should allow to browse for an file (or programs) outside the project directories |
| CxiiExtractedRenderData | |
| CxiiExtractor | |
| CxiiFakeRopeComponent | Simulates the behavior of a rope/cable without physical interaction with the world |
| CxiiFakeRopeComponentManager | |
| CxiiFallbackGameState | XiiFallbackGameState is an xiiGameState that can handle existing worlds when no other game state is available |
| CxiiFd | |
| CxiiFileBrowserAttribute | A property attribute that indicates that the string property should display a file browsing button |
| CxiiFileNameValidator | Basic file name validator. Makes sure that under a given parent folder, the new file name is valid and not already in use by a different file |
| CxiiFileOpenMode | Defines in which mode to open a file |
| CxiiFileReader | The default class to use to read data from a file, implements the xiiStreamReader interface |
| CxiiFileReaderBase | |
| CxiiFileSeekMode | For file seek operations this enum defines from which relative position the seek position is described |
| CxiiFileserveClient | Singleton that represents the client side part of a fileserve connection |
| ►CxiiFileserveClientContext | |
| CDataDir | |
| CFileStatus | |
| CxiiFileserver | A file server allows to serve files from a host PC to another process that is potentially on another device |
| CxiiFileserverApp | A stand-alone application for the xiiFileServer |
| CxiiFileserverEvent | |
| CxiiFileShareMode | Selection specifying file lock behavior on open |
| CxiiFileStats | Holds the stats for a file |
| CxiiFileStatus | Information about a single file on disk. The file might be a document or any other file found in the data directories |
| ►CxiiFileSystem | The xiiFileSystem provides high-level functionality to manage files in a virtual file system |
| CFileEvent | The event data that is broadcast by the xiiFileSystem upon certain file operations |
| CFileEventType | Describes the type of events that are broadcast by the xiiFileSystem |
| CxiiFileSystemIterator | A xiiFileSystemIterator allows to iterate over all files in a certain directory |
| ►CxiiFileSystemIteratorFlags | |
| CBits | |
| ►CxiiFileSystemMirror | |
| CDirEntry | |
| CxiiFileWriter | The default class to use to write data to a file, implements the xiiStreamWriter interface |
| CxiiFileWriterBase | |
| CxiiFixedPoint | Implements fixed point arithmetic for fractional values |
| CxiiFloat16 | A 16 bit IEEE float class. Often called "half" |
| CxiiFloat16Vec2 | A simple helper class to use half-precision floats (xiiFloat16) as vectors |
| CxiiFloat16Vec3 | A simple helper class to use half-precision floats (xiiFloat16) as vectors |
| CxiiFloat16Vec4 | A simple helper class to use half-precision floats (xiiFloat16) as vectors |
| CxiiFloatPropertyAnimEntry | |
| CxiiFogComponent | |
| CxiiFogRenderData | The render data object for ambient light |
| CxiiFolderNameDelegate | Custom delegate for the eqQtAssetBrowserFolderView to enable renaming folders. Does not do any model modifications. Instead, it fires editingFinished when the delegate editor closes |
| CxiiFollowPathComponent | This component makes the xiiGameObject, that it is attached to, move along a path defined by a xiiPathComponent |
| CxiiFollowPathMode | |
| CxiiFormatString | Implements formating of strings with placeholders and formatting options |
| CxiiFormatStringImpl | |
| CxiiForwardEventsToGameStateComponent | This event handler component forwards any message that it receives to the active xiiGameStateBase |
| CxiiForwardRenderPass | A standard forward render pass that renders into the color target |
| CxiiForwardRenderShadingQuality | |
| CxiiFoundation | |
| CxiiFrameAllocator | |
| CxiiFrameCaptureInterface | |
| CxiiFrameDataProvider | |
| CxiiFrameDataProviderBase | |
| CxiiFreeAllResourcesMsg | |
| CxiiFrustum | Represents the frustum of some camera and can be used for culling objects |
| CxiiFunctionArgumentAttributes | Wrapper Attribute to add an attribute to a function argument |
| CxiiFunctionArgumentDescriptor | |
| CxiiFunctionParameterTypeResolver | Template that allows to probe a function for a parameter and return type |
| CxiiFunctionParameterTypeResolver< I, R(*)(P...)> | |
| CxiiFunctionParameterTypeResolver< I, R(Class::*)(P...) const > | |
| CxiiFunctionParameterTypeResolver< I, R(Class::*)(P...)> | |
| CxiiFunctionProperty | |
| CxiiFunctionProperty< R(*)(Args...)> | |
| CxiiFunctionProperty< R(CLASS::*)(Args...) const > | |
| CxiiFunctionProperty< R(CLASS::*)(Args...)> | |
| CxiiFunctionType | Describes what kind of function a property is |
| ►CxiiGALAccessFlags | This describes the access flags |
| CBits | |
| CxiiGALAttachmentLoadOperation | This describes the render pass load operation |
| CxiiGALAttachmentReferenceDescription | This describes the render pass attachment reference |
| CxiiGALAttachmentStoreOperation | This describes the render pass store operation |
| CxiiGALBeginRenderPassDescription | This describes the viewport |
| ►CxiiGALBindFlags | This describes which parts of the pipeline a resource can be bound to. It generally mirrors D3D11_BIND_FLAG enumeration. It is used by the buffer description to describe the bind flags for a buffer, and also used in the texture description to describe the bind flags for a texture |
| CBits | |
| CxiiGALBLASBoundingBoxDescription | This describes the bottom level acceleration structure axis-aligned bounding box |
| CxiiGALBLASTriangleDescription | This describes the bottom level acceleration structure triangles |
| CxiiGALBlendFactor | This describes the blend factor |
| CxiiGALBlendOperation | This describes the blend operation |
| CxiiGALBlendState | Interface that defines methods to manipulate a blend state object |
| CxiiGALBlendStateCreationDescription | This describes the blend state for all render targets in the graphics pipeline |
| CxiiGALBlendStateVulkan | |
| CxiiGALBottomLevelAS | Interface that defines methods to manipulate a bottom level acceleration structure (BLAS) object |
| CxiiGALBottomLevelASCreationDescription | This describes bottom level acceleration structure creation description |
| CxiiGALBottomLevelASVulkan | |
| CxiiGALBuffer | Interface that defines methods to manipulate a buffer object |
| CxiiGALBufferCreationDescription | This describes the buffer creation description |
| CxiiGALBufferData | This describes the buffer initial data |
| CxiiGALBufferMode | This describes the buffer access mode |
| CxiiGALBufferProperties | This describes the buffer properties |
| CxiiGALBufferToTextureCopyDescription | This describes the information required to perform a copy operation between a buffer and a texture |
| CxiiGALBufferView | Interface that defines methods to manipulate a buffer view object |
| CxiiGALBufferViewCreationDescription | This describes the buffer view creation description |
| CxiiGALBufferViewType | This describes the buffer view type used by the buffer view description |
| CxiiGALBufferViewVulkan | |
| CxiiGALBufferVulkan | |
| ►CxiiGALColorMask | This describes the color component write flags |
| CBits | |
| CxiiGALCommandBufferPoolVulkan | |
| ►CxiiGALCommandList | Interface that defines methods to manipulate a command list object |
| CVertexStreamDescription | |
| CxiiGALCommandListCounters | This describes the command list API call counters |
| CxiiGALCommandListCreationDescription | This describes the command list creation description |
| CxiiGALCommandListStatistics | This describes the command list statistics |
| CxiiGALCommandListUtilities | |
| ►CxiiGALCommandListVulkan | |
| ►CCommandListFlags | |
| CBits | |
| CCommandListState | |
| CxiiGALCommandQueue | Interface that defines methods to manipulate a command queue object |
| CxiiGALCommandQueueCreationDescription | This describes the fence creation description |
| CxiiGALCommandQueuePriority | This describes the queue priority |
| CxiiGALCommandQueueProperties | This describes the command queue properties |
| ►CxiiGALCommandQueueType | This describes the command queue type |
| CBits | |
| CxiiGALCommandQueueVulkan | |
| CxiiGALComparisonFunction | This describes a comparison function. This enumeration defines a comparison function. It generally mirrors D3D11_COMPARISON_FUNC/D3D12_COMPARISON_FUNC enumeration |
| CxiiGALComputePipelineState | Interface that defines methods to manipulate a compute pipeline state object |
| CxiiGALComputePipelineStateCreationDescription | This describes the compute pipeline state creation description |
| CxiiGALComputePipelineStateVulkan | |
| CxiiGALComputeShaderProperties | This describes the compute shader properties |
| ►CxiiGALCPUAccessFlag | This describes the allowed CPU access mode flags when mapping a resource. This is used by the buffer and texture descriptions to describe the CPU access mode for buffers and textures |
| CBits | |
| ►CxiiGALCpuWaitOnlyFenceVulkan | |
| CSyncPointData | |
| CxiiGALCullMode | This describes the cull mode |
| CxiiGALDepthStencilClearValue | This describes the optimized depth-stencil clear value |
| CxiiGALDepthStencilState | Interface that defines methods to manipulate a depth stencil state object |
| CxiiGALDepthStencilStateCreationDescription | This describes the depth stencil state creation description |
| CxiiGALDepthStencilStateVulkan | |
| CxiiGALDescriptorHash | Provides hash functions for GAL descriptor objects |
| CxiiGALDescriptorSetPoolVulkan | |
| CxiiGALDevice | Primary interface for interactions with rendering APIs. It contains a set of (non-virtual) functions to set state, create resources etc. which rely on API specific implementations provided by protected virtual functions. Redundant state changes are prevented at the platform independent level in the non-virtual functions |
| CxiiGALDeviceAdapterType | This describes the hardware adapter type |
| CxiiGALDeviceCreationDescription | This describes the graphics device creation description |
| CxiiGALDeviceEvent | This describes the graphics abstraction layer device events |
| CxiiGALDeviceEventType | |
| CxiiGALDeviceFactory | |
| CxiiGALDeviceFeatures | This describes the device features |
| CxiiGALDeviceFeatureState | This describes the graphics device feature state |
| CxiiGALDeviceImplementationDescription | |
| CxiiGALDeviceMemoryProperties | This describes the device memory properties |
| CxiiGALDeviceObject | Base Graphics Abstraction Layer Object |
| CxiiGALDeviceUtilities | Provides utility functions that are common with interfacing with the GAL device |
| CxiiGALDeviceValidationLevel | This describes common validation levels that translate to specific settings for different backends |
| ►CxiiGALDeviceVulkan | |
| CExtensionFeatures | |
| CExtensionProperties | |
| CHasObjectType | |
| CHasObjectType< T, std::void_t< decltype(T::objectType)> > | |
| CxiiGALDispatchComputeDescription | Describes parameters for issuing a compute dispatch call |
| CxiiGALDispatchComputeIndirectDescription | Describes parameters for issuing an indirect compute dispatch call |
| CxiiGALDispatchTileDescription | Describes parameters for issuing a tile-based compute dispatch |
| CxiiGALDisplayModeDescription | This describes the display mode attributes |
| ►CxiiGALDrawCommandCapabilityFlags | This describes the draw command compatibilty flags |
| CBits | |
| CxiiGALDrawCommandProperties | This describes the draw command properties |
| CxiiGALDrawDescription | Describes parameters for issuing non-indexed draw calls |
| CxiiGALDrawIndexedDescription | Describes parameters for issuing indexed draw calls |
| CxiiGALDrawIndexedIndirectDescription | Describes parameters for issuing indirect indexed draw calls |
| CxiiGALDrawIndirectDescription | Describes parameters for issuing indirect non-indexed draw calls |
| CxiiGALDrawMeshDescription | Describes parameters for issuing mesh shader draw calls |
| CxiiGALDrawMeshIndirectDescription | Describes parameters for issuing indirect mesh shader draw calls |
| CxiiGALDynamicBuffer | |
| CxiiGALDynamicBufferAllocationVulkan | |
| ►CxiiGALDynamicBufferPoolVulkan | |
| CDynamicBufferPage | |
| CxiiGALFence | Interface that defines methods to manipulate a fence object |
| CxiiGALFenceCreationDescription | This describes the fence creation description |
| CxiiGALFencePoolVulkan | |
| CxiiGALFenceType | This describes the fence type |
| ►CxiiGALFenceVulkan | |
| CSyncPointData | |
| CxiiGALFillMode | This describes the fill mode |
| CxiiGALFilterType | This describes the filter type |
| CxiiGALFramebuffer | Interface that defines methods to manipulate a frame buffer object |
| CxiiGALFramebufferCreationDescription | This describes the frame buffer creation description |
| CxiiGALFramebufferVulkan | |
| CxiiGALFullScreenModeDescription | This describes the full screen mode description |
| CxiiGALGraphicsAdapterVendor | This describes the graphics device adapter vendor |
| CxiiGALGraphicsDeviceAdapterDescription | This describes the graphics device adapter properties |
| CxiiGALGraphicsDeviceType | Defines the graphics device |
| CxiiGALGraphicsPipelineDescription | This describes graphics pipeline information |
| CxiiGALGraphicsPipelineState | Interface that defines methods to manipulate a graphics pipeline state object |
| CxiiGALGraphicsPipelineStateCreationDescription | This describes the graphics pipeline state creation description |
| CxiiGALGraphicsPipelineStateVulkan | |
| CxiiGALGraphicsUtilities | |
| CxiiGALHitGroupBindingMode | This describes the hit group binding mode used by the top level acceleration structure |
| ►CxiiGALImageCapture | This class provides functionality to capture images from the GPU, typically used for screenshots, debugging or analysis purposes |
| CCaptureDescription | |
| CxiiGALImmutableSamplerDescription | This describes an immutable sampler used by a graphics pipeline |
| CxiiGALInputElementFrequency | This describes the input frequency |
| CxiiGALInputLayout | Interface that defines methods to manipulate an input layout object |
| CxiiGALInputLayoutCreationDescription | This describes the input layout creation description |
| CxiiGALInputLayoutSemantic | This describes the vertex attribute semantic |
| CxiiGALInputLayoutVulkan | |
| CxiiGALLayoutElement | This describes a single element in the input layout |
| CxiiGALLogicOperation | This describes the logic operation |
| ►CxiiGALMapFlags | This describes special arguments for a map operation. This is used to describe addition map flags when mapping buffers and textures |
| CBits | |
| CxiiGALMapHelper | Helper class that automates resource mapping and unmapping |
| CxiiGALMappedTextureSubresource | This describes the mapped texture sub-resource data |
| CxiiGALMapType | This describes how a mapped resource will be accessed. It generally mirrors the D3D11_MAP enumeration. It is used to describe a texture or buffer mapping type |
| ►CxiiGALMemoryPropertyFlags | This describes memory property flags |
| CBits | |
| CxiiGALMeshShaderProperties | This describes the mesh shader properties |
| CxiiGALMipLevelProperties | This describes the mip level properties |
| ►CxiiGALMiscBufferFlags | This describes the miscellaneous buffer flags |
| CBits | |
| ►CxiiGALMiscTextureFlags | This describes the miscellaneous texture flags |
| CBits | |
| CxiiGALMSAASampleCount | This describes the multi-sample count |
| CxiiGALMultiDrawDescription | Describes parameters for issuing a multi-draw call with unindexed geometry |
| CxiiGALMultiDrawIndexedDescription | Describes parameters for issuing a multi-draw call with indexed geometry |
| CxiiGALMultiDrawIndexedItem | Represents a single indexed draw entry in a multi-draw call |
| CxiiGALMultiDrawItem | Represents a single non-indexed draw entry in a multi-draw call |
| CxiiGALNormalizedDeviceCoordinates | This describes the normalized device coordinates attribute |
| CxiiGALObject | Base Graphics Abstraction Layer Object |
| CxiiGALOptimizedClearValue | This describes the optimized color clear value |
| CxiiGALPermutationGenerator | A helper class to iterate over all possible permutations |
| CxiiGALPermutationVariable | |
| CxiiGALPipelineResourceDescription | This describes the pipeline resource information |
| CxiiGALPipelineResourceDescriptionVulkan | |
| ►CxiiGALPipelineResourceFlags | This describes the pipeline resource property flags |
| CBits | |
| CxiiGALPipelineResourceSignature | Interface that defines methods of the pipeline resource signature |
| CxiiGALPipelineResourceSignatureCreationDescription | This describes the pipeline resource signature creation description |
| ►CxiiGALPipelineResourceSignatureVulkan | |
| CImmutableSamplerStorage | |
| ►CxiiGALPipelineShadingRateFlags | This describes the pipeline state shading rate flags |
| CBits | |
| ►CxiiGALPipelineStageFlags | This describes the pipeline stage flags |
| CBits | |
| CxiiGALPipelineState | Interface that defines methods to manipulate a pipeline state object |
| CxiiGALPipelineStateCreationDescription | This describes the pipeline state creation description |
| CxiiGALPipelineType | This describes the shader variable property flags |
| CxiiGALPresentMode | This describes the swap chain present mode |
| CxiiGALPrimitiveTopology | This describes the topology of how vertices are interpreted by the pipeline |
| CxiiGALQuery | Interface that defines methods to manipulate a query object |
| CxiiGALQueryCreationDescription | This describes the query creation description |
| CxiiGALQueryDataBinaryOcclusion | This describes the binary occlusion query data |
| CxiiGALQueryDataDuration | This describes the duration query data |
| CxiiGALQueryDataOcclusion | This describes the occlusion query data |
| CxiiGALQueryDataPipelineStatistics | This describes the pipeline statistics query data |
| CxiiGALQueryDataTimestamp | This describes the timestamp query data |
| CxiiGALQueryPoolVulkan | |
| CxiiGALQueryType | This describes a query type |
| CxiiGALQueryVulkan | |
| CxiiGALQueueInformationVulkan | |
| CxiiGALRasterizerState | Interface that defines methods to manipulate a rasterizer state object |
| CxiiGALRasterizerStateCreationDescription | This describes the rasterizer state creation description |
| CxiiGALRasterizerStateVulkan | |
| ►CxiiGALRayTracingBuildASFlags | This describes the acceleration structure build flags |
| CBits | |
| ►CxiiGALRayTracingCapabilityFlags | This describes the ray tracing capability flags |
| CBits | |
| CxiiGALRayTracingGeneralShaderGroupDescription | This describes the ray tracing general shader group information |
| CxiiGALRayTracingPipelineDescription | This describes the ray tracing pipeline information |
| CxiiGALRayTracingPipelineState | Interface that defines methods to manipulate a ray tracing pipeline state object |
| CxiiGALRayTracingPipelineStateCreationDescription | This describes the mesh pipeline state creation description |
| CxiiGALRayTracingPipelineStateVulkan | |
| CxiiGALRayTracingProceduralHitShaderGroupDescription | This describes the ray tracing general shader group information |
| CxiiGALRayTracingProperties | This describes the ray tracing properties |
| CxiiGALRayTracingTriangleHitShaderGroupDescription | This describes the ray tracing general shader group information |
| CxiiGALRenderPass | Interface that defines methods to manipulate a render pass object |
| CxiiGALRenderPassAttachmentDescription | This describes the render pass attachment creation description |
| CxiiGALRenderPassCreationDescription | This describes the render pass creation description |
| CxiiGALRenderPassVulkan | |
| CxiiGALRenderTargetBlendDescription | This describes the blend state for a single render target |
| CxiiGALResolveTextureSubresourceDescription | This describes multi-sampled texture resolve command arguments |
| CxiiGALResource | Base class for all GAL resources (textures, buffers, etc) |
| CxiiGALResourceDimension | This describes the resorurce dimension. This is used by the texture description to describe the texture type, and the texture view description to describe the texture view type |
| ►CxiiGALResourceDimensionCapabilityFlags | This describes the device support of a particular resource dimension for a given texture format |
| CBits | |
| CxiiGALResourceFormat | This describes the available texture formats and generally mirrors the DXGI_FORMAT enumeratinon. The table below provides detailed information on each format. Most of these formats are widely supported by all modern APIs (DX10+, OpenGL3.3+ and OpenGLES3.0+). Specific requirements are additionally indicated |
| CxiiGALResourceFormatComponentType | This describes the texture format component type |
| CxiiGALResourceFormatDescription | This describes the invariant texture format attributes. These attributes are intrinsic to the texture format itself and do not depend on the format support |
| ►CxiiGALResourceStateFlags | This describes the resource usage state |
| CBits | |
| CxiiGALResourceUsage | |
| CxiiGALResourceView | Base class for all GAL resource views (texture and buffer views) |
| ►CxiiGALSampleCount | This describes the sample count |
| CBits | |
| CxiiGALSampleDescription | This describes the sample information |
| CxiiGALSampler | Interface that defines methods to manipulate a texture sampler object used to perform texture filtering |
| CxiiGALSamplerCreationDescription | This describes the sampler creation description |
| ►CxiiGALSamplerFlags | This describes the sampler flags |
| CBits | |
| CxiiGALSamplerProperties | This describes the texture sampler properties |
| CxiiGALSamplerVulkan | |
| CxiiGALScalingMode | This describes how an image is stretched to fit a given monitor's resolution |
| CxiiGALScanLineOrder | This describes the method the raster uses to create an image on a surface |
| CxiiGALScopedDebugGroup | A helper class for managing debug groups in a command list |
| CxiiGALScratchBufferSizeDescription | This describes the scratch buffer information for the acceleration structure |
| CxiiGALSemaphorePoolVulkan | |
| ►CxiiGALSetVertexBufferFlags | This describes the pipeline state shading rate flags |
| CBits | |
| CxiiGALShader | Interface that defines methods to manipulate a shader object |
| CxiiGALShaderByteCode | This class wraps shader byte code storage |
| CxiiGALShaderCompiler | |
| ►CxiiGALShaderCompilerFlags | Flags that affect the compilation process of a shader |
| CBits | |
| CxiiGALShaderCreationDescription | This describes the shader creation description |
| CxiiGALShaderManager | |
| ►CxiiGALShaderParser | |
| CAttributeDefinition | |
| CEnumDefinition | |
| CEnumValue | |
| CParameterDefinition | |
| CxiiGALShaderPermutationBinary | Serialized state of a shader permutation |
| CxiiGALShaderPrimitiveType | This describes the primitive type of a shader code variable |
| CxiiGALShaderProgramCompiler | Shader compiler interface. Custom shader compilers need to derive from this class and implement the pure virtual interface functions. Instances are created via reflection, so each implementation must be properly reflected |
| ►CxiiGALShaderProgramData | Storage used during the shader compilation process |
| CStageData | |
| CxiiGALShaderResourceDefinition | A shader resource definition found inside the shader source code |
| CxiiGALShaderResourceDescription | This describes shader resource |
| CxiiGALShaderResourceType | This describes the shader resource type |
| CxiiGALShaderResourceVariableDescription | This describes the shader variable information |
| CxiiGALShaderSections | |
| CxiiGALShaderStageBinary | |
| CxiiGALShaderStateResourceDescriptor | |
| CxiiGALShaderTextSectionizer | |
| CxiiGALShaderTextureType | This describes texture type of the shader resource type |
| ►CxiiGALShaderType | This describes the shader stage |
| CBits | |
| CxiiGALShaderVariableClassType | This describes the class type of a shader code variable |
| CxiiGALShaderVariableDescription | This describes shader code variable |
| ►CxiiGALShaderVariableFlags | This describes the shader variable property flags |
| CBits | |
| CxiiGALShaderVulkan | |
| CxiiGALShadingRateAttachmentDescription | This describes the shading rate attachment |
| CxiiGALShadingRateAxis | This describes the base shading rate along a horizontal or vertical axis |
| ►CxiiGALShadingRateCapabilityFlags | This describes the shading rate capability flags |
| CBits | |
| ►CxiiGALShadingRateCombinerFlags | This describes how shading rates coming from the different sources (base rate, primitive rate and VRS image rate) are combined |
| CBits | |
| ►CxiiGALShadingRateFlags | This describes the shading rate for both the horizontal and vertical axes |
| CBits | |
| CxiiGALShadingRateFormat | This describes the shading rate texture format supported by the device |
| CxiiGALShadingRateMode | This describes a combination of a shading rate and multi-sampling mode |
| CxiiGALShadingRateProperties | This describes the shading rate properties |
| CxiiGALShadingRateTextureAccess | This describes the access pattern of the shading rate texture |
| CxiiGALSparseBufferProperties | This describes the sparse buffer properties |
| ►CxiiGALSparseResourceCapabilityFlags | Sparse memory capability flags |
| CBits | |
| CxiiGALSparseResourceProperties | This describes the sparse memory properties |
| ►CxiiGALSparseTextureFlags | This describes the sparse texture packing mode |
| CBits | |
| CxiiGALSparseTextureProperties | This describes the sparse texture properties |
| CxiiGALStagingBufferAllocationVulkan | |
| ►CxiiGALStagingBufferPoolVulkan | |
| CStagingBufferPage | |
| CxiiGALStateTransitionDescription | This describes the resource state barrier description |
| ►CxiiGALStateTransitionFlags | Resource state transition flags |
| CBits | |
| CxiiGALStateTransitionMode | This describes the resource state transition mode |
| CxiiGALStateTransitionType | This describes the resource state transition type |
| CxiiGALStencilOperation | This describes the stencil operation |
| CxiiGALStencilOperationDescription | This describes the stencil operation that are performed on the results of the depth test |
| CxiiGALSubPassDependencyDescription | This describes the sub pass dependency |
| CxiiGALSubPassDescription | This describes the render pass sub pass |
| CxiiGALSurfaceTransform | This describes the transform applied to the image content prior to presentation |
| CxiiGALSwapChain | Interface that defines methods to manipulate a swap chain object |
| CxiiGALSwapChainCreationDescription | This describes the swap chain creation description |
| ►CxiiGALSwapChainUsageFlags | This describes the method the raster uses to create an image on a surface |
| CBits | |
| CxiiGALSwapChainVulkan | |
| CxiiGALTexture | Interface that defines methods to manipulate a texture object |
| CxiiGALTextureAddressMode | This describes the texture address mode. It defines a technique for resolving texture coordinates that are outside of the boundries of a texture. The enumeration generally mirrors D3D11_TEXTURE_ADDRESS_MODE/D3D12_TEXTURE_ADDRESS_MODE enumeration |
| CxiiGALTextureComponentMapping | This describes the per-channel texture component mapping |
| CxiiGALTextureComponentSwizzle | This describes the texture component swizzle |
| CxiiGALTextureCreationDescription | This describes the texture creation description |
| CxiiGALTextureData | This describes the initial data to store in the texture |
| CxiiGALTextureMipLevelData | This describes the mapped texture sub-resource mip-level data |
| CxiiGALTextureProperties | This describes the texture properties |
| CxiiGALTextureSubResourceData | This describes the data for one texture sub-resource |
| CxiiGALTextureUtilities | |
| CxiiGALTextureView | Interface that defines methods to manipulate a texture view object |
| CxiiGALTextureViewCreationDescription | This describes the texture view creation description |
| ►CxiiGALTextureViewFlags | This describes the texture view flags |
| CBits | |
| CxiiGALTextureViewType | This describes the texture view type used by the texture view description |
| CxiiGALTextureViewVulkan | |
| CxiiGALTextureVulkan | |
| CxiiGALTilePipelineDescription | This describes the tile pipeline information |
| CxiiGALTilePipelineState | Interface that defines methods to manipulate a tile pipeline state object |
| CxiiGALTilePipelineStateCreationDescription | This describes the mesh pipeline state creation description |
| CxiiGALTilePipelineStateVulkan | |
| CxiiGALTopLevelAS | Interface that defines methods to manipulate a top level acceleration structure (TLAS) object |
| CxiiGALTopLevelASBuildDescription | This describes the top level acceleration state that was used in the last build |
| CxiiGALTopLevelASCreationDescription | This describes the top level acceleration structure creation description |
| CxiiGALTopLevelASInstanceDescription | This describes the top level acceleration structure instance |
| CxiiGALTopLevelASVulkan | |
| ►CxiiGALUnorderedAccessViewFlags | This describes the unordered access view flags |
| CBits | |
| ►CxiiGALValidationFlags | This describes common validation flags |
| CBits | |
| CxiiGALValueType | This describes the represented value type. It is used by the buffer description to describe the value type of a formatted buffer, and also used to specify the index type for an indexed draw call |
| ►CxiiGALVertexBufferPool | A templated vertex buffer pool that manages dynamic vertex allocations. This divides its memory into one or more chunks to minimize reallocation and supports thread-safe allocation, update, and tracking of vertex usage |
| CAllocationHandle | A handle for a vertex allocation |
| CUsageStatistics | Aggregated usage statistics for the pool |
| CxiiGALVertexInputLayout | Shader Vertex Input Attributes |
| CxiiGALViewport | This describes the viewport. A viewport defines the rendering area within a graphical output. It specifies the position, size, and depth range of the viewport to control how the scene is displayed |
| ►CxiiGALWaveFeature | This describes the wave feature types |
| CBits | |
| CxiiGALWaveOperationProperties | This describes the sampler properties |
| CxiiGameAppInputConfig | |
| CxiiGameApplication | The base class for all typical game applications made with xiiEngine |
| CxiiGameApplicationBase | |
| CxiiGameApplicationExecutionEvent | |
| CxiiGameApplicationStaticEvent | |
| CxiiGameGrid | XiiGameGrid is a general purpose 2D grid structure that has several convenience functions which are often required when working with a grid |
| CxiiGameModeMsgToEditor | |
| CxiiGameModeMsgToEngine | |
| ►CxiiGameObject | This class represents an object inside the world |
| CChildIterator | |
| CConstChildIterator | Iterates over all children of one object |
| CxiiGameObjectContextAction | |
| CxiiGameObjectContextActions | |
| CxiiGameObjectContextDocument | |
| CxiiGameObjectContextEvent | |
| CxiiGameObjectContextPreferencesUser | |
| CxiiGameObjectDesc | Describes the initial state of a game object |
| ►CxiiGameObjectDocument | |
| CGameModeData | |
| CxiiGameObjectDocumentAction | |
| CxiiGameObjectDocumentActions | |
| CxiiGameObjectDocumentEvent | |
| CxiiGameObjectEditTool | |
| CxiiGameObjectEvent | |
| CxiiGameObjectGizmoEditTool | |
| CxiiGameObjectGizmoInterface | |
| CxiiGameObjectHandle | A handle to a game object |
| CxiiGameObjectId | Internal game object id used by xiiGameObjectHandle |
| CxiiGameObjectMetaData | |
| CxiiGameObjectOnLayerDragDropHandler | |
| CxiiGameObjectReferenceAttribute | A property attribute that indicates that the string property is actually a game object reference |
| CxiiGameObjectSelectionAction | |
| CxiiGameObjectSelectionActions | |
| CxiiGameState | XiiGameState implements the xiiGameStateBase interface and adds several convenience features |
| CxiiGameStateBase | XiiGameStateBase is the base class for all game states. Game states are used to implement custom high level game logic |
| CxiiGameStateWindow | A window class that expands a little on xiiWindow. Default type used by xiiGameState to create a window |
| CxiiGatherObjectsForDebugVisMsgInterDoc | |
| ►CxiiGatherObjectsOfTypeMsgInterDoc | Send between editor documents, such that one document can know about objects in another document |
| CResult | |
| CxiiGenericId | A generic id class that holds an id combined of an instance index and a generation counter |
| ►CxiiGeometry | Provides functions to generate standard geometric shapes, such as boxes, spheres, cylinders, etc |
| CGeoOptions | Options shared among all geometry creation functions |
| CLine | A line only references two vertices |
| CPolygon | Each polygon has a face normal and a set of indices, which vertices it references |
| CVertex | The data that is stored per vertex |
| CxiiGetBlackboardBoolAnimNode | |
| CxiiGetBlackboardNumberAnimNode | |
| CxiiGetStrongestTypeClass | |
| CxiiGetTypeClass | If there is an % operator which takes a xiiTypeIsMemRelocatable and returns a CompileTimeTrueType T is Pod. Default % operator return false |
| CxiiGizmo | |
| CxiiGizmoAction | |
| CxiiGizmoComponent | Used by the editor to render gizmo meshes |
| CxiiGizmoComponentManager | |
| CxiiGizmoEvent | |
| ►CxiiGizmoFlags | |
| CBits | |
| CxiiGizmoHandle | |
| CxiiGizmoRenderData | |
| CxiiGizmoRenderer | |
| CxiiGlobalBlackboardComponent | This component references a global blackboard by name. If necessary, the blackboard will be created |
| CxiiGlobalBlackboardInitMode | |
| ►CxiiGlobalEvent | A class to broadcast and handle global (system-wide) events |
| CEventData | |
| CxiiGlobalLog | This is the standard log system that xiiLog sends all messages to |
| CxiiGlobalSettingsMsgToEngine | |
| ►CxiiGPUResourcePool | This class serves as a pool for GPU related resources (e.g. buffers and textures required for rendering). Note that the functions creating and returning render targets are thread safe (by using a mutex) |
| CBufferHandleWithAge | |
| CTextureHandleWithAge | |
| CxiiGrabbableItemComponent | Used to define 'grab points' on an object where a player can pick up and hold the item |
| CxiiGrabbableItemGrabPoint | |
| CxiiGraphicsPipelinePass | |
| CxiiGraphPatch | Patch base class for xiiAbstractObjectGraph patches |
| CxiiGraphPatchContext | Handles the patching of a node. Is passed into the patch classes to provide utility functions and track the node's patching progress |
| CxiiGraphVersioning | Singleton that allows version patching of xiiAbstractObjectGraph |
| CxiiGraphVersioningHash | Hash helper class for xiiVersionKey |
| CxiiGreyBoxComponent | |
| CxiiGreyBoxEditTool | |
| CxiiGreyBoxShape | |
| ►CxiiGridNavmesh | Takes a xiiGameGrid and creates an optimized navmesh structure from it, that is more efficient for path searches |
| CAreaEdge | |
| CConvexArea | |
| CxiiGridRenderData | |
| CxiiGridRenderer | |
| CxiiGridSettingsMsgToEngine | |
| CxiiGroupAttribute | Used to categorize properties into groups |
| CxiiHandedness | For selecting a left-handed or right-handed convention |
| CxiiHashableStruct | This class provides a base class for hashable structs (e.g. descriptor objects) |
| ►CxiiHashedString | This class is optimized to take nearly no memory (sizeof(void*)) and to allow very fast checks whether two strings are identical |
| CHashedData | |
| CxiiHashHelper | Helper struct to calculate the Hash of different types |
| CxiiHashHelper< const char * > | |
| CxiiHashHelper< T * > | |
| CxiiHashHelper< vk::DescriptorType > | |
| CxiiHashHelper< xiiArchiveStoredString > | Functions to enable xiiHashTable to 1) store xiiArchiveStoredString and 2) lookup strings efficiently with a xiiArchiveLookupString |
| CxiiHashHelper< xiiComponentHandle > | HashHelper implementation so component handles can be used as key in a hashtable |
| CxiiHashHelper< xiiDebugRendererContext > | |
| CxiiHashHelper< xiiExposedBone > | |
| CxiiHashHelper< xiiGameObjectHandle > | HashHelper implementation so game object handles can be used as key in a hash table |
| CxiiHashHelper< xiiHashedString > | |
| CxiiHashHelper< xiiInt32 > | |
| CxiiHashHelper< xiiInt64 > | |
| CxiiHashHelper< xiiReflectionProbeId > | |
| CxiiHashHelper< xiiReflectionProbeRef > | |
| CxiiHashHelper< xiiScriptCoroutineHandle > | HashHelper implementation so coroutine handles can be used as key in a hash table. Also needed to store in a variant |
| CxiiHashHelper< xiiScriptWorldModule::FunctionContext > | |
| CxiiHashHelper< xiiStringView > | |
| CxiiHashHelper< xiiTempHashedString > | |
| CxiiHashHelper< xiiTypedResourceHandle< T > > | |
| CxiiHashHelper< xiiTypelessResourceHandle > | |
| CxiiHashHelper< xiiUInt32 > | |
| CxiiHashHelper< xiiUInt64 > | |
| CxiiHashHelper< xiiUuid > | |
| CxiiHashHelper< xiiVariant > | |
| CxiiHashHelper< xiiViewHandle > | HashHelper implementation so view handles can be used as key in a hashtable |
| CxiiHashHelperString_NoCase | Hash helper to be used as a template argument to xiiHashTable / xiiHashSet for case insensitive string keys |
| CxiiHashingUtils | This class provides implementations of different hashing algorithms |
| CxiiHashSet | |
| ►CxiiHashSetBase | Implementation of a hashset |
| CConstIterator | Const iterator |
| CxiiHashStreamWriter32 | A stream writer that hashes the data written to it |
| CxiiHashStreamWriter64 | A stream writer that hashes the data written to it |
| CxiiHashTable | |
| CxiiHashTableBase | Implementation of a hashtable which stores key/value pairs |
| ►CxiiHashTableBaseConstIterator | Const iterator |
| CPointer | |
| ►CxiiHashTableBaseIterator | Iterator with write access |
| CPointer | |
| CxiiHeadBoneComponent | Applies a vertical rotation in local space (local Y axis) to the owner game object |
| CxiiHeightfieldComponent | This component utilizes a greyscale image to generate an elevation mesh, which is typically used for simple terrain |
| CxiiHeightfieldComponentManager | |
| CxiiHelpActions | |
| CxiiHiddenAttribute | A property attribute that indicates that the property is not to be shown in the UI |
| CxiiHistorySourcePass | Allows to access data from a previous frame. Always comes in a pair with a xiiHistoryTargetPass. To preserve textures across the next frame you need to create this node to define the type of texture and initial state. This node's output pin will give access to the previous frame's content. Next, create a xiiHistoryTargetPass. It's input pin exposes the same texture as provided by the source node but allows you to write to by connecting the input pin to another pass that produces the image that you want to carry to the next frame. To connect a xiiHistoryTargetPass to its counterpart you need to set it's "SourcePassName" property to the name of the xiiHistorySourcePass you want to match. As both nodes expose the same texture, special care has to be taken that it's not used as input and output of another pass at the same time. In those cases, add a xiiCopyTexturePass to break up invalid state |
| CxiiHistorySourcePassTextureDataProvider | |
| CxiiHistoryTargetPass | Allows to write data to be accessible in the next frame. See xiiHistorySourcePass for usage |
| CxiiHMDInfo | |
| ►CxiiHybridArray | A hybrid array uses in-place storage to handle the first few elements without any allocation. It dynamically resizes when more elements are needed |
| Calignas | The fixed size array |
| CxiiHybridString | |
| CxiiHybridStringBase | A string class for storing and passing around strings |
| CxiiIDE | |
| CxiiIdTable | |
| ►CxiiIdTableBase | Implementation of an id mapping table which stores id/value pairs |
| CConstIterator | Const iterator |
| CIterator | Iterator with write access |
| CxiiIkJointEntry | |
| CxiiImage | A class containing image data and associated meta data |
| CxiiImageAddressMode | |
| ►CxiiImageConversion | Helper class containing utilities to convert between different image formats and layouts |
| CConversionPathNode | A single node along a computed conversion path |
| CxiiImageConversionEntry | A structure describing the pairs of source/target format that may be converted using the conversion routine |
| CxiiImageConversionStep | Interface for a single image conversion step |
| CxiiImageConversionStepCompressBlocks | Interface for a single image conversion step where the source format is uncompressed and the target format is compressed |
| CxiiImageConversionStepDecompressBlocks | Interface for a single image conversion step where the source format is compressed and the target format is uncompressed |
| CxiiImageConversionStepDeplanarize | Interface for a single image conversion step from a planar to a linear format |
| CxiiImageConversionStepLinear | Interface for a single image conversion step where both the source and target format are uncompressed |
| CxiiImageConversionStepPlanarize | Interface for a single image conversion step from a linear to a planar format |
| CxiiImageDataAssetDocument | |
| CxiiImageDataAssetDocumentManager | |
| CxiiImageDataAssetEvent | |
| CxiiImageDataAssetProperties | |
| CxiiImageDataResource | |
| CxiiImageDataResourceDescriptor | |
| CxiiImageFileFormat | |
| CxiiImageFileFormatRegistrator | Template used to automatically register a xiiImageFileFormat globally |
| CxiiImageFilter | Represents a function used for filtering an image |
| CxiiImageFilterBox | Box filter |
| CxiiImageFilterSincWithKaiserWindow | Kaiser-windowed sinc filter |
| CxiiImageFilterTriangle | Triangle filter |
| CxiiImageFilterWeights | Pre-computes the required filter weights for rescaling a sequence of image samples |
| CxiiImageFormat | Enum describing the encoding format of the pixels of an image |
| CxiiImageFormatChannel | Enum describing the channel of an image format |
| CxiiImageFormatDataType | Enum describing the channel type of an image format |
| CxiiImageFormatMappings | Helper class containing methods to convert between xiiImageFormat::Enum and platform-specific image formats |
| CxiiImageFormatType | Enum describing the type of an image format |
| CxiiImageHeader | A class containing image meta data, such as format and dimensions |
| CxiiImageSizeofHelper | |
| CxiiImageSizeofHelper< const void > | |
| CxiiImageSizeofHelper< void > | |
| CxiiImageSliderUiAttribute | Displays the value range as an image, allowing users to pick a value like on a slider |
| ►CxiiImageUtils | |
| CMipMapOptions | Mip map generation options |
| CxiiImageView | A class referencing image data and holding metadata about the image |
| CxiiInDevelopmentAttribute | A property attribute that indicates that this feature is still in development and should not be shown to all users |
| CxiiInputActionConfig | A struct that defines how to register an input action |
| CxiiInputComponent | This component polls all input events from the given input set every frame and broadcasts the information to components on the same game object |
| CxiiInputDevice | The base class for all input device types |
| ►CxiiInputDeviceController | This class is the base class for all controller type input devices |
| CMotor | Describes which vibration motor to configure |
| CxiiInputDeviceMouseKeyboard | This is the base class for all input devices that handle mouse and keyboard input |
| CxiiInputLayoutInfo | |
| ►CxiiInputManager | The central class to set up and query the state of all input |
| CInputEventData | The data that is broadcast when certain events occur |
| CxiiInputMessageGranularity | Which types of input events are broadcast |
| ►CxiiInputSlotFlags | These flags are specified when registering an input slot (by a device), to define some capabilities and restrictions of the hardware |
| CBits | |
| CxiiInsertObjectPropertyCommand | |
| CxiiInstanceData | |
| CxiiInstanceDataAllocator | Helper class to manager instance data allocation, construction and destruction |
| CxiiInstanceDataDesc | Structure to describe an instance data type |
| CxiiInstanceDataProvider | |
| CxiiInstancedMeshComponent | Renders multiple instances of the same mesh |
| CxiiInstancedMeshComponentManager | |
| CxiiInstancedMeshRenderData | |
| CxiiInstantiatePrefabCommand | |
| CxiiInt64DoubleUnion | Simple helper union to store ints and doubles to modify their bit patterns |
| CxiiIntensityControlPoint | |
| CxiiInterval | Represents an interval with a start and an end value |
| CxiiIntervalScheduler | |
| CxiiIntervalSchedulerBase | Helper class to schedule work in intervals typically larger than the duration of one frame |
| CxiiIntFloatUnion | Simple helper union to store ints and floats to modify their bit patterns |
| ►CxiiIpcChannel | Base class for a communication channel between processes |
| CConnectionState | |
| CMode | |
| CxiiIpcChannelEvent | Event data for xiiIpcChannel::m_Events |
| CxiiIPCObjectMirrorEditor | An object mirror that mirrors across IPC to the engine process |
| CxiiIPCObjectMirrorEngine | An object mirror that mirrors across IPC to the engine process |
| CxiiIpcProcessMessageProtocol | A protocol around xiiIpcChannel to send reflected messages instead of byte array messages between client and server |
| CxiiIReflectedTypeAccessor | Provides access to the properties of a xiiRTTI compatible data storage |
| CxiiIsBitflags | Determines whether a type is xiiIsBitflags |
| CxiiIsBitflags< xiiBitflags< T > > | |
| CxiiIsEnum | Determines whether a type is xiiIsBitflags |
| CxiiIsEnum< xiiEnum< T > > | |
| CxiiIsOutParam | |
| CxiiIsOutParam< T & > | |
| CxiiIsOutParam< T * > | |
| CxiiIsPodType | If there is an % operator which takes a TypeIsPod and returns a CompileTimeTrueType T is Pod. Default % operator return false |
| CxiiIsPodType< T * > | Pointers are POD types |
| CxiiIsPodType< T[N]> | Arrays are POD types |
| CxiiIsStandardType | Used to determine if the given type is a build-in standard variant type |
| CxiiIsStandardType< T, xiiVariant > | |
| CxiiIsValueType | Used to determine if the given type can be stored by value inside a xiiVariant (either standard type or custom type) |
| CxiiIsValueType< T, xiiVariant > | |
| CxiiIterateBitIndices | Helper class to iterate over the bit indices of an integer. The class can iterate over the bits of any unsigned integer type that is equal to or smaller than xiiUInt64 |
| CxiiIterateBits | |
| CxiiIterateBitValues | Helper class to iterate over the bit values of an integer. The class can iterate over the bits of any unsigned integer type that is equal to or smaller than xiiUInt64 |
| CxiiJointAttachmentComponent | Used to expose an animated mesh's bone as a game object, such that objects can be attached to it to move along |
| CxiiJointOverrideComponent | Overrides the local transform of a bone in a skeletal animation |
| CxiiJSONParser | A low level JSON parser that can incrementally parse the structure of a JSON document |
| ►CxiiJSONReader | This JSON reader will read an entire JSON document into a hierarchical structure of xiiVariants |
| CElement | |
| CxiiJSONWriter | The base class for JSON writers |
| CxiiKeyState | This struct defines the different states a key can be in. All keys always go through the states 'Pressed' and 'Released', even if they are active for only one frame. A key is 'Down' when it is pressed for at least two frames. It is 'Up' when it is not pressed for at least two frames |
| CxiiLambdaDelegateStorage | |
| CxiiLambdaDelegateStorageBase | [Internal] Storage for lambdas with captures in xiiDelegate |
| CxiiLargeBlockAllocator | A block allocator which can only allocates blocks of memory at once |
| CxiiLayerAction | |
| CxiiLayerActions | |
| CxiiLayerContext | Layers that are loaded as sub-documents of a scene share the xiiWorld with their main document scene. Thus, this context attaches itself to its parent xiiSceneContext |
| CxiiLayerDocument | |
| CxiiLayerDocumentSettings | |
| CxiiLayerDragDropHandler | Base class for drag and drop handler that drop on a xiiSceneLayer |
| CxiiLayerOnLayerDragDropHandler | |
| CxiiLayerVisibilityChangedMsgToEngine | |
| CxiiLensFlareComponent | |
| CxiiLensFlareElement | Represents an individual element of a lens flare |
| CxiiLensFlareRenderData | |
| CxiiLensFlareRenderer | Implements rendering of lens flares |
| CxiiLerpPosesAnimNode | |
| CxiiLightComponent | Base class for all xii light components containing shared properties |
| CxiiLightRenderData | Base class for light render data objects |
| CxiiLineToComponent | Draws a line from its own position to the target object position |
| CxiiLineToComponentManager | |
| CxiiList | |
| ►CxiiListBase | A List-class, similar to STL::list |
| CIterator | A forward-iterator. Allows sequential access from front-to-back |
| CxiiLocalAllocatorWrapper | |
| CxiiLocalBlackboardComponent | This component creates its own xiiBlackboard, and thus locally holds state |
| CxiiLock | Manages a lock (e.g. a mutex) and ensures that it is properly released as the lock object goes out of scope |
| CxiiLockedObject | Provides access to an object while managing a lock (e.g. a mutex) that ensures that during its lifetime the access to the object happens under the lock |
| CxiiLodAnimatedMeshComponent | |
| CxiiLodAnimatedMeshComponentManager | |
| CxiiLodAnimatedMeshLod | |
| CxiiLodMeshComponent | Renders one of several level-of-detail meshes depending on the distance to the camera |
| CxiiLodMeshLod | |
| CxiiLog | Static class that allows to write out logging information |
| CxiiLogAnimNode | |
| CxiiLogBlock | Instances of this class will group messages in a scoped block together |
| CxiiLogEntry | A persistent log entry created from a xiiLoggingEventData. Allows for a log event to survive for longer than just the event and is reflected, allowing for it to be sent to remote targets |
| CxiiLogEntryDelegate | A log interface implementation that converts a log event into a xiiLogEntry and calls a delegate with it |
| CxiiLogErrorAnimNode | |
| CxiiLoggingEventData | The data that is sent through xiiLogInterface |
| CxiiLogicAndAnimNode | |
| CxiiLogicEventAndAnimNode | |
| CxiiLogicNotAnimNode | |
| CxiiLogicOrAnimNode | |
| CxiiLogInfoAnimNode | |
| CxiiLogInterface | Base class for all logging classes |
| CxiiLogMsgToEditor | |
| CxiiLogMsgType | Describes the types of events that xiiLog sends |
| CxiiLogSystemScope | A class that sets a custom xiiLogInterface as the thread local default log system, and resets the previous system when it goes out of scope |
| CxiiLogSystemToBuffer | A simple log interface implementation that gathers all messages in a string buffer |
| CxiiLongOpAttribute | Used to mark that a component provides functionality that is executed with a long operation in the editor |
| CxiiLongOpControllerEvent | Events about all known long ops. Broadcast by xiiLongOpControllerManager |
| ►CxiiLongOpControllerManager | The LongOp controller is active in the editor process and manages which long ops are available, running, etc |
| CProxyOpInfo | Holds all information about the proxy long op on the editor side |
| CxiiLongOpManager | Base class with shared functionality for xiiLongOpControllerManager and xiiLongOpWorkerManager |
| CxiiLongOpProgressMsg | |
| CxiiLongOpProxy | Proxy long ops represent a long operation on the editor side |
| CxiiLongOpProxy_BakeScene | |
| CxiiLongOpReplicationMsg | |
| CxiiLongOpResultMsg | |
| CxiiLongOpsAdapter | This singleton lives in the editor process and monitors all xiiSceneDocument's for components with the xiiLongOpAttribute |
| CxiiLongOpWorker | Worker long ops are executed by the editor engine process |
| CxiiLongOpWorker_BakeScene | |
| CxiiLongOpWorkerManager | The LongOp worker manager is active in the engine process of the editor |
| CxiiLUTAssetActions | |
| CxiiLUTAssetDocument | |
| CxiiLUTAssetDocumentGenerator | |
| CxiiLUTAssetDocumentManager | |
| CxiiLUTAssetProperties | |
| CxiiMakeDelegateHelper | |
| CxiiMakeDelegateHelper< R(Class::*)(Args...) const > | |
| CxiiMakeDelegateHelper< R(Class::*)(Args...)> | |
| CxiiManipulatorAdapter | |
| CxiiManipulatorAdapterRegistry | |
| CxiiManipulatorAttribute | |
| CxiiManipulatorManager | |
| CxiiManipulatorManagerEvent | |
| CxiiManipulatorScaleGizmo | Scale gizmo version that only uses boxes that can be composited with rotate and translate gizmos without major overlap. Used by the xiiTransformManipulatorAdapter |
| CxiiMap | |
| CxiiMapBase | An associative container. Similar to STL::map |
| ►CxiiMapBaseConstIteratorBase | Base class for all iterators |
| CPointer | |
| ►CxiiMapBaseIteratorBase | Forward Iterator to iterate over all elements in sorted order |
| CPointer | |
| CxiiMapPropertyAccessor | |
| CxiiMarkerComponent | |
| CxiiMat3Template | A 3x3 component matrix class |
| CxiiMat4Template | A 4x4 component matrix class |
| CxiiMaterialAssetActions | |
| CxiiMaterialAssetDocument | |
| CxiiMaterialAssetDocumentManager | |
| CxiiMaterialAssetPreview | |
| CxiiMaterialAssetProperties | |
| CxiiMaterialContext | |
| CxiiMaterialDragDropHandler | |
| CxiiMaterialModelAction | |
| CxiiMaterialObjectManager | |
| CxiiMaterialResource | |
| ►CxiiMaterialResourceDescriptor | |
| CParameter | |
| CTexture2DBinding | |
| CTextureCubeBinding | |
| CxiiMaterialResourceSlot | |
| CxiiMaterialShaderMode | |
| CxiiMaterialViewContext | |
| CxiiMaterialVisualShaderEvent | |
| CxiiMathDoubleBits | |
| ►CxiiMathExpression | A wrapper around xiiExpression infrastructure to evaluate simple math expressions |
| CInput | |
| CxiiMathExpressionAnimNode | |
| CxiiMathFloatBits | |
| CxiiMatOrTransform | Enables a function to take an xiiMat3, xiiMat4 or xiiTransfrom |
| CxiiMatrixLayout | Enum to describe which memory layout is used to store a matrix in a float array |
| CxiiMaxArraySizeAttribute | A property attribute that specifies the max size of an array. If it is reached, no further elemets are allowed to be added |
| CxiiMemberArrayProperty | |
| CxiiMemberArrayReadOnlyProperty | Read only version of xiiMemberArrayProperty that does not call any functions that modify the array. This is needed to reflect xiiArrayPtr members |
| CxiiMemberFunctionParameterTypeResolver | Template that allows to probe a single parameter function for parameter and return type |
| CxiiMemberFunctionParameterTypeResolver< R(Class::*)(P)> | |
| CxiiMemberMapProperty | |
| CxiiMemberProperty | [internal] An implementation of xiiTypedMemberProperty that accesses the property data directly |
| CxiiMemberSetProperty | |
| CxiiMemberSetProperty< Class, xiiTagSet, xiiStringView > | |
| CxiiMemoryMappedFile | Allows to map an entire file into memory for random access |
| CxiiMemoryMappedFileImpl | |
| CxiiMemoryStreamContainerStorage | Templated implementation of xiiMemoryStreamStorageInterface that adapts most standard XII containers to the interface |
| CxiiMemoryStreamContainerWrapperStorage | Wrapper around an existing container to implement xiiMemoryStreamStorageInterface |
| CxiiMemoryStreamReader | A reader which can access a memory stream |
| CxiiMemoryStreamStorageInterface | Instances of this class act as storage for memory streams |
| CxiiMemoryStreamWriter | A writer which can access a memory stream |
| ►CxiiMemoryTracker | Memory tracker which keeps track of all allocations and constructions |
| CAllocationInfo | |
| CIterator | |
| CxiiMemoryUtils | This class provides functions to work on raw memory |
| CxiiMenuAction | An action that represents a sub-menu. Can be within a menu bar, or the menu of a tool button) |
| CxiiMeshAssetDocument | |
| CxiiMeshAssetDocumentGenerator | |
| CxiiMeshAssetDocumentManager | |
| CxiiMeshAssetProperties | |
| CxiiMeshBoneWeigthPrecision | |
| CxiiMeshBufferResource | |
| CxiiMeshBufferResourceDescriptor | |
| CxiiMeshBufferUtils | |
| CxiiMeshComponent | Renders a single instance of a static mesh |
| CxiiMeshComponentBase | Base class for components that render static or animated meshes |
| CxiiMeshComponentDragDropHandler | |
| CxiiMeshContext | |
| CxiiMeshImportTransform | |
| CxiiMeshInstanceData | |
| CxiiMeshNormalPrecision | |
| CxiiMeshPrimitive | |
| CxiiMeshRenderData | |
| CxiiMeshRenderer | Implements rendering of static meshes |
| CxiiMeshResource | |
| ►CxiiMeshResourceDescriptor | |
| CBoneData | |
| CMaterial | |
| CSubMesh | |
| CxiiMeshTexCoordPrecision | |
| CxiiMeshVertexColorConversion | |
| CxiiMeshViewContext | |
| CxiiMessage | Base class for all message types. Each message type has it's own id which is used to dispatch messages efficiently |
| CxiiMessageLoop | Internal sub-system used by xiiIpcChannel |
| CxiiMessageLoop_NoImpl | |
| CxiiMessageQueue | |
| ►CxiiMessageQueueBase | Implementation of a message queue on top of a deque |
| CEntry | |
| CxiiMessageSenderBase | Base class for all message senders |
| CxiiMessageSenderInfo | |
| CxiiMiniDumpUtils | Functionality for writing process mini-dumps (callstacks, memory snapshots, etc) |
| CxiiMinValueTextAttribute | Used to show a text instead of the minimum value of a property |
| CxiiMouseCursorClipMode | Specifies how to restrict movement of the Operating System mouse |
| CxiiMoveNodeCommand | |
| CxiiMoveObjectCommand | |
| CxiiMoveObjectPropertyCommand | |
| CxiiMoveToComponent | A light-weight component that moves the owner object towards a single position |
| ►CxiiMoveToComponentFlags | |
| CBits | |
| CxiiMsaaResolvePass | |
| CxiiMsaaUpscalePass | |
| CxiiMsgAnimationPoseGeneration | Sent to objects when a parent component is generating an animation pose, to inject additional pose commands, for instance to apply inverse kinematics (IK) |
| CxiiMsgAnimationPosePreparing | Used by components that skin a mesh to inform children whenever a new pose is being prepared |
| CxiiMsgAnimationPoseUpdated | Used by components that skin a mesh to inform children whenever a new pose has been computed |
| CxiiMsgAnimationReachedEnd | Sent when an animation reached its end (either forwards or backwards playing) |
| CxiiMsgApplyRootMotion | This message is sent when animation root motion data is available |
| CxiiMsgBlackboardEntryChanged | |
| CxiiMsgBuildStaticMesh | |
| CxiiMsgChildrenChanged | |
| CxiiMsgCollision | |
| CxiiMsgComponentInternalTrigger | For internal use by components to trigger some known behavior. Usually components will post this message to themselves with a delay, e.g. to trigger self destruction |
| CxiiMsgComponentsChanged | |
| CxiiMsgDamage | |
| CxiiMsgDeleteGameObject | |
| CxiiMsgExtractGeometry | Sent by xiiWorldGeoExtractionUtil to gather geometry information about objects in a world |
| CxiiMsgExtractOccluderData | |
| CxiiMsgExtractRenderData | |
| CxiiMsgGenericEvent | For use in scripts to signal a custom event that some game event has occurred |
| CxiiMsgInputActionTriggered | XiiInputComponent raises this event when it detects input |
| CxiiMsgInterruptPlaying | Common message for components that can or need to be canceled immediately |
| CxiiMsgMoveCharacterController | |
| CxiiMsgObjectGrabbed | Sent by components such as xiiJoltGrabObjectComponent to indicate that the object has been grabbed or released |
| CxiiMsgOnlyApplyToObject | |
| CxiiMsgParentChanged | |
| CxiiMsgPathChanged | |
| CxiiMsgPhysicsAddForce | Used to apply a physical force on the object |
| CxiiMsgPhysicsAddImpulse | Used to apply a physical impulse on the object |
| CxiiMsgPhysicsJointBroke | |
| CxiiMsgQueryAnimationSkeleton | The animated mesh component listens to this message and 'answers' by filling out the skeleton resource handle |
| CxiiMsgReleaseObjectGrab | Send this to components such as xiiJoltGrabObjectComponent to demand that m_hGrabbedObjectToRelease should no longer be grabbed |
| CxiiMsgRetrieveBoneState | Queries the local transforms of each bone in an object with a skeleton |
| CxiiMsgRopePoseUpdated | Used by components that do rope simulation and rendering |
| CxiiMsgSensorDetectedObjectsChanged | |
| CxiiMsgSetColor | A message to modify the main color of some thing |
| CxiiMsgSetDoubleParameter | Basic message to set some generic parameter to a double value |
| CxiiMsgSetFloatParameter | Basic message to set some generic parameter to a float value |
| CxiiMsgSetMeshMaterial | This message is used to replace the material on a mesh |
| CxiiMsgSetPlaying | Common message for components that can be toggled between playing and paused states |
| CxiiMsgSetRealParameter | Basic message to set some generic parameter to a xiiReal value |
| CxiiMsgStateMachineStateChanged | Message that is sent by xiiStateMachineState_SendMsg once the state is entered |
| CxiiMsgTransformChanged | |
| CxiiMsgTriggerTriggered | Sent when something enters or leaves a trigger |
| CxiiMsgUpdateLocalBounds | |
| CxiiMuteLog | Used to ignore all log messages |
| CxiiMutex | Provides a simple mechanism for mutual exclusion to prevent multiple threads from accessing a shared resource simultaneously |
| CxiiNamedAction | |
| CxiiNavmeshGeoWorldModuleInterface | A world module that retrieves triangle data that should be used for building navmeshes at runtime |
| CxiiNavmeshTriangle | |
| CxiiNoBase | Dummy type to pass to templates and macros that expect a base type for a class that has no base |
| CxiiNodeCommandAccessor | |
| CxiiNodeCommands | |
| CxiiNodeCreationTemplate | Describes a template that will be used to create new nodes. In most cases this only contains the type but it can also contain properties that are pre-filled when the node is created |
| ►CxiiNodeFlags | |
| CBits | |
| CxiiNodePropertyValue | |
| CxiiNoEventData | Can be used when xiiEvent is used without any additional data |
| CxiiNoMutex | A dummy mutex that does no locking |
| CxiiNonUniformBoxGizmo | |
| CxiiNonUniformBoxManipulatorAdapter | |
| CxiiNonUniformBoxManipulatorAttribute | |
| CxiiNoTemporaryTransactionsAttribute | This attribute indicates that a widget should not use temporary transactions when changing the value |
| CxiiNullAllocatorWrapper | |
| CxiiObjectAccessorBase | |
| CxiiObjectAccessorChangeEvent | |
| CxiiObjectChange | An object change starts at the heap object m_Root (because we can only safely store pointers to those). From this object we follow m_Steps (member arrays, structs) to execute m_Change at the end target |
| CxiiObjectChangeType | |
| CxiiObjectCommandAccessor | |
| CxiiObjectDirectAccessor | |
| ►CxiiObjectFlags | Internal flags of game objects or components |
| CBits | |
| ►CxiiObjectMetaData | Stores meta data for document objects that is not part of the object itself. E.g. editor-only states like hidden or prefab information |
| CEventData | |
| CStorage | |
| CxiiObjectMode | Specifies the mode of an object. This enum is only used in the editor |
| CxiiObjectMsgQueueType | Specifies at which phase the queued message should be processed |
| CxiiObjectPickingResult | |
| CxiiObjectPropertyPath | |
| CxiiObjectPropertyPathContext | |
| CxiiObjectProxyAccessor | |
| CxiiObjectSelection | Stores a list of game objects as a 'selection'. Provides some common convenience functions for working with selections |
| CxiiObjectSelectionMsgToEngine | |
| CxiiObjectsForDebugVisMsgToEngine | Send by the editor scene document to the runtime scene document, to tell it about the poll results (see xiiGatherObjectsForDebugVisMsgInterDoc) |
| CxiiObjectTagMsgToEngine | |
| ►CxiiOBJLoader | A loader class for OBJ/MTL files |
| CFace | Holds all data about one face (ie. polygon, not only triangles) |
| CFaceVertex | Stores the information for a vertex in a face |
| CMaterial | Holds the information about one Material |
| CxiiOccluderComponent | |
| CxiiOccluderComponentManager | |
| CxiiOnBlackboardValueChangedAnimNode | |
| CxiiOnComponentFinishedAction | Certain components may delete themselves or their owner when they are finished with their main purpose |
| CxiiOnComponentFinishedAction2 | Same as xiiOnComponentFinishedAction, but additionally includes 'Restart' |
| CxiiOnTaskRunning | Enum that describes what to do when waiting for or canceling tasks, that have already started execution |
| CxiiOpaqueForwardRenderPass | A forward render pass that renders all opaque objects into the color target |
| CxiiOpenDdlParser | A low level parser for the OpenDDL format. It can incrementally parse the structure, individual blocks can be skipped |
| CxiiOpenDdlReader | An OpenDDL reader parses an entire DDL document and creates an in-memory representation of the document structure |
| CxiiOpenDdlReaderElement | Represents a single 'object' in a DDL document, e.g. either a custom type or a primitives list |
| ►CxiiOpenDdlWriter | The base class for OpenDDL writers |
| CDdlState | |
| CxiiOrbitCameraContext | A simple orbit camera. Use LMB to rotate, wheel to zoom, Alt to slow down |
| CxiiOrthoGizmoContext | |
| ►CxiiOSFile | This is an abstraction for the most important file operations |
| CEventData | The data that is sent through the event interface |
| CEventType | Describes the types of events that xiiOSFile sends |
| CxiiOSThread | Implementation of a thread |
| CxiiOzzArchiveData | Stores or gather the data for an ozz file, for random access operations (seek / tell) |
| CxiiOzzStreamReader | Implements the ozz::io::Stream interface for reading. The data has to be present in a xiiOzzArchiveData object |
| CxiiOzzStreamWriter | Implements the ozz::io::Stream interface for writing. The data is gathered in a xiiOzzArchiveData object |
| CxiiPageAllocator | This helper class can reserve and allocate whole memory pages |
| CxiiParallelForParams | Settings for xiiTaskSystem::ParallelFor invocations |
| CxiiPasteObjectsCommand | |
| ►CxiiPathComponent | Describes a path shape |
| CControlPoint | The 'raw' data for a single path control point |
| CLinearizedElement | If the path is linearized, this represents a single sample point |
| CLinearSampler | An object that keeps track of where one is sampling the path component |
| CxiiPathComponentManager | |
| CxiiPathNodeComponent | Attach this to child object of a xiiPathComponent to turn them into viable path nodes |
| CxiiPathNodeTangentMode | The different modes that tangents may use in a path node |
| CxiiPathPattern | Describes a single path pattern |
| CxiiPathPatternFilter | A collection of xiiPathPatterns |
| ►CxiiPathSearch | Implements a directed breadth-first search through a graph (A*) |
| CPathResultData | FindPath() and FindClosest() return an array of these objects as the path result |
| CxiiPathState | Base class for all path finding state objects |
| CxiiPathStateGenerator | The base class for all path state generates |
| CxiiPathUtils | Contains Helper functions to work with paths |
| CxiiPerspectiveAction | |
| CxiiPhantomArrayProperty | |
| CxiiPhantomConstantProperty | |
| CxiiPhantomFunctionProperty | |
| CxiiPhantomMapProperty | |
| CxiiPhantomMemberProperty | |
| CxiiPhantomRTTI | |
| CxiiPhantomRttiManager | Manages all xiiPhantomRTTI types that have been added to him |
| CxiiPhantomRttiManagerEvent | |
| CxiiPhantomSetProperty | |
| CxiiPhantomTypeChange | Event message used by the xiiPhantomRttiManager |
| CxiiPhysicsCastResult | Used for raycast and seep tests |
| CxiiPhysicsCastResultArray | |
| CxiiPhysicsOverlapResult | Used to report overlap query results |
| CxiiPhysicsOverlapResultArray | |
| CxiiPhysicsQueryParameters | |
| ►CxiiPhysicsWorldModuleInterface | |
| CFixedJointConfig | |
| CJointConfig | |
| CxiiPickingRenderPass | |
| CxiiPin | |
| CxiiPipeWin | |
| CxiiPlaneTemplate | A class that represents a mathematical plane |
| CxiiPlatformDescription | |
| CxiiPlatformProfile | |
| CxiiPlayerApplication | |
| CxiiPlayerStartPointComponent | |
| ►CxiiPlugin | XiiPlugin manages all dynamically loadable plugins |
| CInit | |
| CPluginInfo | Contains basic information about a loaded plugin |
| CxiiPluginBundle | A plugin bundle lists all the files and information needed to get one feature plugin working both in the editor and the runtime |
| CxiiPluginBundleSet | Contains multiple xiiPluginBundle's |
| CxiiPluginEvent | The data that is broadcast whenever a plugin is (un-) loaded |
| ►CxiiPluginLoadFlags | Flags for loading a plugin |
| CBits | |
| CxiiPluginRegister | Helper struct to register the existence of statically linked plugins. The macro XII_STATICLINK_LIBRARY will register a the given library name prepended with xii to the xiiPlugin system. Implemented in Plugin.cpp |
| CxiiPointerWithFlags | A wrapper around a raw pointer that allows to use the lower N bits for flags |
| CxiiPointLightComponent | The standard point light component. This component represents point lights with various properties (e.g. a projected cube map, range, etc.) |
| CxiiPointLightRenderData | The render data object for point lights |
| CxiiPointLightVisualizerAdapter | |
| CxiiPointLightVisualizerAttribute | A special visualizer attribute for point lights |
| CxiiPoseResultAnimNode | |
| CxiiPositionOnPlane | Describes on which side of a plane a point or an object is located |
| CxiiPostProcessingComponent | A component that sets the configured values on a render pipeline and optionally samples those values from volumes at the corresponding camera position |
| CxiiPostProcessingComponentManager | |
| CxiiPostProcessingValueMapping | |
| CxiiPowerConnectorComponent | This component is for propagating the flow of power in cables or fluid in pipes and determine whether it arrives at a receiver |
| CxiiPrefabCache | |
| CxiiPrefabComponentDragDropHandler | |
| CxiiPrefabDefaultStateProvider | Default state provider that reflects the default state defined in the prefab template |
| CxiiPrefabDocumentSettings | |
| CxiiPrefabInstantiationOptions | |
| CxiiPrefabReferenceComponent | The central component to instantiate prefabs |
| CxiiPrefabReferenceComponentManager | |
| CxiiPrefabResource | |
| CxiiPrefabResourceDescriptor | |
| CxiiPrefabUtils | |
| CxiiPreferences | Base class for all preferences |
| ►CxiiPreprocessor | XiiPreprocessor implements a standard C preprocessor. It can be used to pre-process files to get the output after macro expansion and #ifdef handling |
| CProcessingEvent | The event data that the processor broadcasts |
| CxiiPresentPipelinePass | |
| CxiiPreventDuplicatesAttribute | If this attribute is set, the UI is encouraged to prevent the user from creating duplicates of the same thing |
| ►CxiiProbeFlags | Flags that describe a reflection probe |
| CBits | |
| CxiiProbeTreeSectorResource | |
| CxiiProbeTreeSectorResourceDescriptor | |
| CxiiProcessAssetMsg | |
| CxiiProcessAssetResponseMsg | |
| ►CxiiProcessCommunicationChannel | |
| CEvent | |
| CxiiProcessGroupImpl | |
| ►CxiiProcessImpl | |
| CStdStreamInfo | |
| CxiiProcessingStream | A single stream in a stream group holding contiguous data of a given type |
| CxiiProcessingStreamGroup | A stream group encapsulates the streams and the corresponding data processors |
| CxiiProcessingStreamIterator | Helper template class to iterate over stream elements |
| CxiiProcessingStreamProcessor | Base class for all stream processor implementations |
| CxiiProcessingStreamSpawnerZeroInitialized | This element spawner initializes new elements with 0 (by writing 0 bytes into the whole element) |
| CxiiProcessMessage | Base class for IPC messages transmitted by xiiIpcChannel |
| CxiiProcessTask | |
| CxiiProcessThread | |
| CxiiProfileConfigData | Base class for configuration objects that store e.g. asset transform settings or runtime configuration information |
| CxiiProfilingListScope | This class implements a profiling scope similar to xiiProfilingScope, but with additional sub-scopes which can be added easily without introducing actual C++ scopes |
| CxiiProfilingScope | This class encapsulates a profiling scope |
| ►CxiiProfilingSystem | Helper functionality of the profiling system |
| CCPUScope | |
| CCPUScopesBufferFlat | |
| CGPUScope | Helper struct to hold GPU profiling data |
| CProfilingData | |
| CThreadInfo | |
| CxiiProfilingUtils | |
| CxiiProgress | Manages the way a progress bar is subdivided and advanced |
| CxiiProgressEvent | Through these events the state of a xiiProgress instance is communicated |
| CxiiProgressRange | XiiProgressRange is the preferred method to inform the system of progress |
| CxiiProjectAction | |
| CxiiProjectActions | |
| CxiiProjectExport | |
| CxiiProjectileComponent | Shoots a game object in a straight line and uses physics raycasts to detect hits |
| CxiiProjectileReaction | Defines what a projectile will do when it hits a surface |
| CxiiProjectileSurfaceInteraction | Holds the information about how a projectile interacts with a specific surface type |
| CxiiProjectPreferencesUser | Stores project specific preferences for the current user |
| CxiiProjectReadyMsgToEditor | |
| CxiiPropertyAccessor | [internal] Helper class to generate accessor functions for (private) members of another class |
| CxiiPropertyAnimAssetDocument | |
| CxiiPropertyAnimAssetDocumentEvent | |
| CxiiPropertyAnimAssetDocumentManager | |
| CxiiPropertyAnimationTrack | |
| CxiiPropertyAnimationTrackGroup | |
| ►CxiiPropertyAnimComponent | Animates properties on other objects and components according to the property animation resource |
| CBinding | |
| CColorBinding | |
| CComponentFloatBinding | |
| CFloatBinding | |
| CGameObjectBinding | |
| CxiiPropertyAnimEntry | |
| CxiiPropertyAnimMode | Describes how an animation should be played back |
| CxiiPropertyAnimObjectAccessor | |
| CxiiPropertyAnimObjectManager | |
| CxiiPropertyAnimResource | |
| CxiiPropertyAnimResourceDescriptor | |
| CxiiPropertyAnimTarget | What data type an animation modifies |
| CxiiPropertyAttribute | Base class of all attributes can be used to decorate a RTTI property |
| CxiiPropertyCategory | Describes what category a property belongs to |
| CxiiPropertyClipboard | |
| CxiiPropertyEvent | |
| ►CxiiPropertyFlags | Flags used to describe a property and its type |
| CBits | |
| CxiiPropertyMetaState | This class allows to query additional information about how to present properties in the property grid |
| CxiiPropertyMetaStateEvent | Event that is broadcast whenever information about how to present properties is required |
| CxiiPropertyPath | Stores a path from an object of a given type to a property inside of it. Once initialized to a specific path, the target property/object of the path can be read or written on multiple root objects. An empty path is allowed in which case WriteToLeafObject/ReadFromLeafObject will return pRootObject directly |
| CxiiPropertyPathStep | Reflected property step that can be used to init a xiiPropertyPath |
| CxiiPropertyReference | |
| CxiiPropertySelection | |
| CxiiPropertyUiState | Describes the current meta state of a property for display purposes in the property grid |
| CxiiPullObjectStateMsgToEngine | |
| CxiiPushObjectStateData | |
| CxiiPushObjectStateMsgToEditor | |
| CxiiQGridBarWidget | |
| CxiiQtActionProxy | |
| CxiiQtAddSubElementButton | |
| CxiiQtAnimatedMeshAssetDocumentWindow | |
| CxiiQtAnimationClipAssetDocumentWindow | |
| CxiiQtAnimationGraphAssetDocumentWindow | |
| CxiiQtAnimationGraphAssetScene | |
| CxiiQtAnimationGraphNode | |
| CxiiQtApplicationPanel | Base class for all panels that are supposed to be application wide (not tied to some document) |
| CxiiQtAssetBrowserDlg | |
| CxiiQtAssetBrowserFilter | |
| CxiiQtAssetBrowserModel | Model of the item view in the asset browser |
| CxiiQtAssetBrowserPanel | The application wide panel that shows and asset browser |
| CxiiQtAssetBrowserView | |
| CxiiQtAssetBrowserWidget | |
| CxiiQtAssetCuratorFilter | |
| CxiiQtAssetCuratorPanel | |
| CxiiQtAssetFilter | Interface class of the asset filter used to decide which items are shown in the asset browser |
| CxiiQtAssetImportDlg | |
| CxiiQtAssetLineEdit | A QLineEdit that is used by xiiQtAssetPropertyWidget |
| CxiiQtAssetProfilesDlg | |
| CxiiQtAssetPropertyWidget | *** Asset Browser *** |
| CxiiQtAssetStatusIndicator | |
| CxiiQtBlackboardTemplateAssetDocumentWindow | |
| CxiiQtButtonProxy | |
| CxiiQtCategoryProxy | |
| CxiiQtCodeEditorPreferencesWidget | |
| CxiiQtCollapsibleGroupBox | |
| CxiiQtCollectionAssetDocumentWindow | |
| CxiiQtColorAreaWidget | |
| CxiiQtColorButtonWidget | *** COLOR *** |
| CxiiQtColorCompareWidget | |
| CxiiQtColorDialog | |
| CxiiQtColorGradientAssetDocumentWindow | |
| CxiiQtColorGradientEditorWidget | |
| CxiiQtColorGradientWidget | |
| CxiiQtColorRangeWidget | |
| CxiiQtCompilerPreferencesWidget | |
| CxiiQtConnection | |
| CxiiQtContainerWindow | Container window that hosts documents and applications panels |
| CxiiQtCppProjectDlg | |
| CxiiQtCreateProjectDlg | |
| CxiiQtCuratorControl | |
| CxiiQtCurve1DAssetDocumentWindow | |
| CxiiQtCurve1DButtonWidget | *** CURVE1D *** |
| CxiiQtCurve1DEditorWidget | |
| CxiiQtCurveEditDlg | |
| CxiiQtCurveEditWidget | |
| CxiiQtCustomDataAssetDocumentWindow | |
| CxiiQtCVarItemDelegate | |
| ►CxiiQtCVarModel | |
| CEntry | |
| CxiiQtCVarPanel | |
| CxiiQtCVarsWidget | |
| CxiiQtCVarWidget | Displays CVar values in a table and allows to modify them |
| CxiiQtDashboardDlg | |
| CxiiQtDataDirsDlg | |
| CxiiQtDataWidget | |
| CxiiQtDecalAssetDocumentWindow | |
| CxiiQtDeltaTransformDlg | |
| CxiiQtDocumentPanel | |
| CxiiQtDocumentTreeModel | Model that maps a document to a qt tree model |
| CxiiQtDocumentTreeModelAdapter | Adapter that defines data for specific type in the xiiQtDocumentTreeModel |
| CxiiQtDocumentTreeView | |
| CxiiQtDocumentWindow | Base class for all document windows. Handles the most basic document window management |
| CxiiQtDocumentWindowEvent | |
| CxiiQtDoubleSpinBox | |
| CxiiQtDummyAdapter | Convenience class that returns the typename as Qt::DisplayRole. Use this for testing or for the document root that can't be seen and is just for defining the hierarchy |
| CxiiQtDuplicateDlg | |
| CxiiQtDynamicActionAndMenuProxy | |
| CxiiQtDynamicBitflagsPropertyWidget | |
| CxiiQtDynamicEnumPropertyWidget | *** Asset Browser *** |
| CxiiQtDynamicMenuProxy | |
| CxiiQtDynamicStringEnumPropertyWidget | |
| CxiiQtEditDynamicEnumsDlg | |
| ►CxiiQtEditorApp | |
| ►CStartupFlags | |
| CBits | |
| CxiiQtElementGroupButton | |
| CxiiQtEmbeddedClassPropertyWidget | Base class for more 'advanced' property type widgets for Pointer or Class type properties. Implements some of xiiQtTypeWidget functionality at property widget level |
| CxiiQtEngineDocumentWindow | Base class for all document windows that need a connection to the engine process, and might want to render 3D content |
| ►CxiiQtEngineViewWidget | Base class for views that show engine output |
| CInteractionContext | Holds information about the viewport that the user just now hovered over and what object was picked last |
| CxiiQtEventTrackEditorWidget | |
| ►CxiiQtEventTrackWidget | |
| CSelectedPoint | |
| CxiiQtExportAndRunDlg | |
| CxiiQtExportProjectDlg | |
| CxiiQtExposedBoneWidget | |
| CxiiQtExposedParameterPropertyWidget | |
| CxiiQtExposedParametersPropertyWidget | |
| CxiiQtExternalFilePropertyWidget | |
| CxiiQtExtractGeometryDlg | |
| CxiiQtFileLineEdit | A QLineEdit that is used by xiiQtFilePropertyWidget |
| CxiiQtFilePropertyWidget | |
| CxiiQtFileserveActivityItem | |
| CxiiQtFileserveActivityModel | |
| CxiiQtFileserveAllFilesModel | |
| CxiiQtFileserveWidget | A GUI for the xiiFileServer |
| CxiiQtFileWidget | |
| CxiiQtGameObjectAdapter | |
| CxiiQtGameObjectDelegate | Custom delegate for game objects, used in xiiQtGameObjectWidget |
| CxiiQtGameObjectDocumentWindow | |
| CxiiQtGameObjectModel | |
| CxiiQtGameObjectPanel | |
| CxiiQtGameObjectReferencePropertyWidget | |
| CxiiQtGameObjectViewWidget | |
| CxiiQtGameObjectWidget | |
| CxiiQtGlobalEventsWidget | |
| CxiiQtGraphicsView | |
| CxiiQtGroupBoxBase | |
| CxiiQtIconViewDelegate | |
| CxiiQtImageCache | A singleton class that caches Qt images that are typically used for thumbnails |
| CxiiQtImageDataAssetDocumentWindow | |
| CxiiQtImageScene | |
| CxiiQtImageSliderWidget | *** SLIDER *** |
| CxiiQtImageWidget | |
| CxiiQtInlinedGroupBox | |
| CxiiQtInputConfigDlg | |
| CxiiQtInputWidget | |
| CxiiQtItemDelegate | In combination with xiiQtItemView this delegate allows for receiving the full range of mouse input |
| CxiiQtItemView | Template to be used with classes derived from QAbstractItemView. Allows the use of xiiQtItemDelegate |
| CxiiQtJointAdapter | |
| CxiiQtLabeledSlider | |
| CxiiQtLaunchFileserveDlg | |
| CxiiQtLayerAdapter | Custom adapter for layers, used in xiiQtLayerPanel |
| CxiiQtLayerDelegate | Custom delegate for layers, used in xiiQtLayerPanel. Provides buttons to toggle the layer visible / loaded states. Relies on xiiQtLayerAdapter to trigger updates and provide the LayerGuid |
| CxiiQtLayerModel | Custom model for layers, used in xiiQtLayerPanel |
| CxiiQtLayerPanel | |
| CxiiQtLogDockWidget | |
| CxiiQtLogModel | The Qt model that represents log output for a view |
| CxiiQtLogPanel | The application wide panel that shows the engine log output and the editor log output |
| CxiiQtLogWidget | The application wide panel that shows the engine log output and the editor log output |
| CxiiQtLongOpsPanel | This panel listens to events from xiiLongOpControllerManager and displays all currently known long operations |
| CxiiQtLUTAssetDocumentWindow | |
| CxiiQtMainWidget | |
| CxiiQtMainWindow | |
| CxiiQtManipulatorLabel | |
| CxiiQtMaterialAssetDocumentWindow | |
| CxiiQtMemoryWidget | |
| CxiiQtMenuActionMapView | |
| CxiiQtMenuBarActionMapView | |
| CxiiQtMenuProxy | |
| CxiiQtMeshAssetDocumentWindow | |
| CxiiQtModifiedDocumentsDlg | |
| CxiiQtNameableAdapter | Convenience class that implements setting the name via a property on the object |
| CxiiQtNamedAdapter | Convenience class that implements getting the name via a property on the object |
| CxiiQtNode | |
| ►CxiiQtNodeScene | |
| ►CConnectionDecorationFlags | |
| CBits | |
| CConnectionStyle | |
| CxiiQtNodeView | |
| CxiiQtOrbitCamViewWidget | |
| ►CxiiQtPickDocumentObjectDlg | |
| CElement | |
| CxiiQtPin | |
| CxiiQtPluginSelectionDlg | |
| CxiiQtPluginSelectionWidget | |
| CxiiQtPluginsWidget | |
| CxiiQtPreferencesDlg | |
| CxiiQtProgressbar | A Qt implementation to display the state of a xiiProgress instance |
| CxiiQtPropertyAnimAssetDocumentWindow | |
| CxiiQtPropertyAnimAssetTreeView | |
| CxiiQtPropertyAnimModel | |
| CxiiQtPropertyAnimModelTreeEntry | |
| ►CxiiQtPropertyContainerWidget | Base class for all container properties |
| CElement | |
| CxiiQtPropertyEditorBitflagsWidget | *** BITFLAGS COMBOBOX *** |
| CxiiQtPropertyEditorCheckboxWidget | *** CHECKBOX *** |
| CxiiQtPropertyEditorColorWidget | |
| CxiiQtPropertyEditorCurve1DWidget | |
| CxiiQtPropertyEditorDoubleAngleWidget | *** DOUBLE ANGLE SPINBOX *** |
| CxiiQtPropertyEditorDoubleQuaternionWidget | *** DOUBLE QUATERNION *** |
| CxiiQtPropertyEditorDoubleSpinboxWidget | *** DOUBLE SPINBOX *** |
| CxiiQtPropertyEditorEnumWidget | *** ENUM COMBOBOX *** |
| CxiiQtPropertyEditorExpressionWidget | |
| CxiiQtPropertyEditorFloatAngleWidget | *** FLOAT ANGLE SPINBOX *** |
| CxiiQtPropertyEditorFloatQuaternionWidget | *** FLOAT QUATERNION *** |
| CxiiQtPropertyEditorFloatSpinboxWidget | *** FLOAT SPINBOX *** |
| CxiiQtPropertyEditorIntSpinboxWidget | *** INT SPINBOX *** |
| CxiiQtPropertyEditorLineEditWidget | *** LINEEDIT *** |
| CxiiQtPropertyEditorSliderWidget | |
| CxiiQtPropertyEditorTagSetWidget | |
| CxiiQtPropertyEditorTimeWidget | *** TIME SPINBOX *** |
| CxiiQtPropertyEditorUIntSpinboxWidget | *** UINT SPINBOX *** |
| CxiiQtPropertyGridWidget | |
| CxiiQtPropertyPointerWidget | Used for property types that are pointers |
| CxiiQtPropertyStandardTypeContainerWidget | |
| CxiiQtPropertyTypeContainerWidget | |
| CxiiQtPropertyTypeWidget | |
| CxiiQtPropertyWidget | Base class for all property widgets |
| CxiiQtProxy | Glue class that maps xiiActions to QActions. QActions are only created if the xiiAction is actually mapped somewhere. Document and Global actions are manually executed and don't solely rely on Qt's ShortcutContext setting to prevent ambiguous action shortcuts |
| CxiiQtQuadViewWidget | |
| CxiiQtReflectionWidget | |
| ►CxiiQtRemoteConnectionDlg | |
| CAddress | |
| CxiiQtRenderPipelineAssetDocumentWindow | |
| CxiiQtRenderPipelineAssetScene | |
| CxiiQtResourceWidget | |
| CxiiQtRttiTypeStringPropertyWidget | |
| CxiiQtScene2DocumentWindow | |
| CxiiQtSceneDocumentWindow | |
| CxiiQtSceneDocumentWindowBase | |
| CxiiQtScenegraphModel | |
| CxiiQtScenegraphPanel | |
| CxiiQtSceneViewWidget | |
| CxiiQtScopedBlockSignals | Calls blockSignals(true) on all given QObjects, and the reverse in the destructor. Can be nested |
| CxiiQtScopedUpdatesDisabled | Calls setUpdatesEnabled(false) on all given QObjects, and the reverse in the destructor. Can be nested |
| CxiiQtSearchableMenu | Implements an item for insertion into a QMenu that shows a search bar and a hierarchical list of options |
| CxiiQtSearchWidget | A widget that contains a line edit for a search text and a button to clear the search text |
| CxiiQtSettingsTab | |
| CxiiQtShaderTemplateDlg | |
| CxiiQtShortcutEditorDlg | |
| CxiiQtSkeletonAssetDocumentWindow | |
| CxiiQtSkeletonPanel | |
| CxiiQtSliderProxy | |
| CxiiQtSliderWidgetAction | |
| CxiiQtSnapSettingsDlg | |
| CxiiQtStandardPropertyWidget | Base class for most 'simple' property type widgets. Implements some of the standard functionality |
| CxiiQtStateMachineAssetDocumentWindow | |
| CxiiQtStateMachineAssetScene | |
| CxiiQtStateMachineConnection | |
| CxiiQtStateMachineNode | |
| CxiiQtStateMachinePin | |
| CxiiQtStatVisWidget | |
| CxiiQtSubsystemsWidget | |
| CxiiQtSurfaceAssetDocumentWindow | |
| CxiiQtTagsDlg | |
| CxiiQtTextureAssetDocumentWindow | |
| CxiiQtTextureCubeAssetDocumentWindow | |
| CxiiQtTimeScrubberToolbar | |
| CxiiQtTimeScrubberWidget | |
| CxiiQtTimeWidget | |
| CxiiQtToolBarActionMapView | |
| CxiiQtTreeSearchFilterModel | |
| CxiiQtTypeMenu | |
| CxiiQtTypeWidget | |
| ►CxiiQtUiServices | |
| CEvent | |
| CTickEvent | |
| CxiiQtUnsupportedPropertyWidget | Fallback widget for all property types for which no other widget type is registered |
| CxiiQtVarianceTypeWidget | |
| CxiiQtVariantPropertyWidget | |
| CxiiQtVersionChecker | Downloads a web page and checks whether the latest version online is newer than the current one |
| CxiiQtViewWidgetContainer | Wraps and decorates a view widget with a toolbar and layout |
| CxiiQtVisualScriptConnection | |
| CxiiQtVisualScriptNode | |
| CxiiQtVisualScriptNodeScene | |
| CxiiQtVisualScriptPin | |
| CxiiQtVisualScriptVariableWidget | |
| CxiiQtVisualScriptWindow | |
| CxiiQtVisualShaderNode | |
| CxiiQtVisualShaderPin | |
| CxiiQtVisualShaderScene | |
| CxiiQtWaitForOperationDlg | |
| CxiiQtWindowCfgDlg | |
| CxiiQuadViewAction | |
| CxiiQuadViewActions | |
| CxiiQuadViewPreferencesUser | |
| CxiiQuakeConsole | A Quake-style console for in-game configuration of xiiCVar and xiiConsoleFunction |
| CxiiQuatTemplate | Quaternions can be used to represent rotations in 3D space |
| CxiiQuerySelectionBBoxMsgToEngine | |
| CxiiQuerySelectionBBoxResultMsgToEditor | |
| CxiiRandom | A random number generator. Currently uses the WELL512 algorithm |
| CxiiRandomGauss | A random number generator that produces values with a normal / Gaussian distribution |
| ►CxiiRangeView | This class uses delegates to define a range of values that can be enumerated using a forward iterator |
| CConstIterator | Const iterator, don't use directly, use ranged based for loops or call begin() end() |
| CIterator | Iterator, don't use directly, use ranged based for loops or call begin() end() |
| CxiiRasterizationResult | Enum values for the result of some rasterization functions |
| CxiiRasterizerObject | |
| CxiiRasterizerView | |
| CxiiRasterizerViewPool | |
| CxiiRational | A class which can be used to represent rational numbers by stating their numerator and denominator |
| CxiiRawMemoryStreamReader | Maps a raw chunk of memory to the xiiStreamReader interface |
| CxiiRawMemoryStreamWriter | Maps a raw chunk of memory to the xiiStreamReader interface |
| CxiiRaycastComponent | A component which does a ray cast and positions a target object there |
| CxiiRaycastComponentManager | |
| CxiiReadOnlyAttribute | A property attribute that indicates that the property may not be modified through the UI |
| CxiiRecentDocumentsMenuAction | |
| ►CxiiRecentFilesList | Maintains a list of recently used files and the container window ID they previously resided in |
| CRecentFile | Struct that defines the file and container window of the recent file list |
| CxiiRecentProjectsMenuAction | |
| CxiiRectTemplate | A simple rectangle class templated on the type for x, y and width, height |
| CxiiRefCounted | Base class for reference counted objects |
| CxiiRefCountedContainer | |
| CxiiRefCountingImpl | |
| CxiiReflectedClass | All classes that should be dynamically reflectable, need to be derived from this base class |
| CxiiReflectedFunctionDescriptor | Stores the description of a reflected function in a serializable form, used by xiiReflectedTypeDescriptor |
| CxiiReflectedPropertyDescriptor | Stores the description of a reflected property in a serializable form, used by xiiReflectedTypeDescriptor |
| CxiiReflectedTypeDescriptor | Stores the description of a reflected type in a serializable form. Used by xiiPhantomRttiManager to add new types |
| CxiiReflectedTypeStorageAccessor | A xiiIReflectedTypeAccessor implementation that also stores the actual data that is defined in the passed xiiRTTI |
| CxiiReflectedTypeStorageManager | Manages all xiiReflectedTypeStorageAccessor instances |
| CxiiReflectionFilterPass | |
| ►CxiiReflectionPool | |
| ►CData | XiiReflectionPool::Data |
| CProbeData | |
| CWorldReflectionData | |
| CxiiReflectionProbeComponentBase | Base class for all reflection probes |
| CxiiReflectionProbeDesc | Describes how a cube map should be generated |
| CxiiReflectionProbeMapping | This class creates a reflection probe atlas and controls the mapping of added probes to the available atlas indices |
| CxiiReflectionProbeMappingEvent | Event generated on mapping changes |
| CxiiReflectionProbeMode | |
| CxiiReflectionProbeRef | A unique reference to a reflection probe |
| CxiiReflectionProbeRenderData | Render data for a reflection probe |
| ►CxiiReflectionProbeUpdater | Renders reflection probes and stores filtered mipmap chains into an atlas texture as well as computing sky irradiance Rendering sky irradiance is optional and only done if m_iIrradianceOutputIndex != -1 |
| CTargetSlot | Defines the target specular reflection probe atlas and index as well as the sky irradiance atlas and index in case the rendered cube map is a sky light |
| CxiiReflectionSerializer | |
| ►CxiiReflectionUtils | Helper functions for handling reflection related operations |
| CEnumConversionMode | |
| CEnumKeyValuePair | |
| CxiiRegisteredImageFileFormat | Base class for a registered (globally known) xiiImageFileFormat |
| CxiiReloadResourceMsgToEngine | |
| CxiiRemoteEngineProcessViewContext | |
| CxiiRemoteEvent | Event type for connections |
| CxiiRemoteInterface | |
| CxiiRemoteMessage | Encapsulates all the data that is transmitted when sending or receiving a message with xiiRemoteInterface |
| CxiiRemoteMessageQueue | |
| CxiiRemoteProcessWindow | |
| CxiiRemoteThread | The remote interface thread updates in regular intervals to keep the connection alive |
| CxiiRemoteToolingInterface | Interface to give access to the FileServe client for additional tooling needs |
| CxiiRemoveNodeCommand | |
| CxiiRemoveObjectCommand | |
| CxiiRemoveObjectPropertyCommand | |
| CxiiRenderComponent | Base class for objects that should be rendered |
| CxiiRenderContext | Provides an interface for issuing GPU rendering and compute commands within a single rendering scope |
| ►CxiiRenderContextFlags | |
| CBits | |
| ►CxiiRenderData | Base class for all render data. Render data must contain all information that is needed to render the corresponding object |
| CCaching | |
| CCategory | |
| ►CxiiRenderDataBatch | |
| CIterator | |
| CxiiRenderDataBatchList | |
| CxiiRenderDoc | RenderDoc implementation of the xiiFrameCaptureInterface interface |
| CxiiRenderer | This is the base class for types that handle rendering of different object types |
| CxiiRenderingSetup | |
| CxiiRenderModeAction | |
| CxiiRenderPipeline | |
| CxiiRenderPipelineAssetDocument | |
| CxiiRenderPipelineAssetManager | |
| CxiiRenderPipelineContext | |
| CxiiRenderPipelineNode | Base class for all nodes in the render pipeline graph |
| CxiiRenderPipelineNodeInputAccelerationStructurePin | Consumes a ray-tracing acceleration structure |
| CxiiRenderPipelineNodeInputAccelerationStructureProviderPin | Dynamically provides an acceleration structure each frame (Input + Provider) |
| CxiiRenderPipelineNodeInputBufferPin | Consumes a general-purpose GPU buffer (uniforms, storage, vertex data, etc.) |
| CxiiRenderPipelineNodeInputBufferProviderPin | Dynamically provides a buffer each frame (Input + Provider) |
| CxiiRenderPipelineNodeInputColourAttachmentPin | Consumes a color render target (e.g. MRT, texture for post-process) |
| CxiiRenderPipelineNodeInputColourAttachmentProviderPin | Dynamically provides a color render target each frame (Input + Provider) |
| CxiiRenderPipelineNodeInputDepthAttachmentPin | Consumes a depth buffer for depth-based effects or tests |
| CxiiRenderPipelineNodeInputDepthAttachmentProviderPin | Dynamically provides a depth render target each frame (Input + Provider) |
| CxiiRenderPipelineNodeInputSamplerPin | Consumes a sampler state for texture sampling configuration |
| CxiiRenderPipelineNodeInputSamplerProviderPin | Dynamically provides a sampler state each frame (Input + Provider) |
| CxiiRenderPipelineNodeManager | |
| CxiiRenderPipelineNodeOutputAccelerationStructurePin | Produces a ray-tracing acceleration structure |
| CxiiRenderPipelineNodeOutputAccelerationStructureProviderPin | Dynamically provides a ray-tracing acceleration structure each frame (Output + Provider) |
| CxiiRenderPipelineNodeOutputBufferPin | Produces a general-purpose GPU buffer (uniforms, storage, vertex data, etc.) |
| CxiiRenderPipelineNodeOutputBufferProviderPin | Dynamically provides a buffer each frame (Output + Provider) |
| CxiiRenderPipelineNodeOutputColourAttachmentPin | Produces a color render target (e.g. MRT, texture for post-process) |
| CxiiRenderPipelineNodeOutputColourAttachmentProviderPin | Dynamically provides a color render target each frame (Output + Provider) |
| CxiiRenderPipelineNodeOutputDepthAttachmentPin | Produces a depth buffer for depth-based effects or tests |
| CxiiRenderPipelineNodeOutputDepthAttachmentProviderPin | Dynamically provides a depth render target each frame (Output + Provider) |
| CxiiRenderPipelineNodeOutputSamplerPin | Produces a sampler state for texture sampling configuration |
| CxiiRenderPipelineNodeOutputSamplerProviderPin | Dynamically provides a sampler state each frame (Output + Provider) |
| CxiiRenderPipelineNodePassThroughAccelerationStructurePin | Forwards an acceleration structure without modifying it |
| CxiiRenderPipelineNodePassThroughBufferPin | Forwards a general-purpose GPU buffer without modifying it |
| CxiiRenderPipelineNodePassThroughColourAttachmentPin | Forwards a color render target without modifying it |
| CxiiRenderPipelineNodePassThroughDepthAttachmentPin | Forwards a depth buffer without modifying it |
| CxiiRenderPipelineNodePassThroughSamplerPin | Forwards a sampler state without modifying it |
| CxiiRenderPipelineNodePin | |
| ►CxiiRenderPipelineNodePinFlags | Flags that describe the behavior and role of a node pin within the render pipeline |
| CBits | |
| CxiiRenderPipelineNodePinResourceType | Describes the kind of resource a render graph node pin accepts or produces |
| CxiiRenderPipelinePass | |
| CxiiRenderPipelinePassBase | |
| CxiiRenderPipelinePassConcurrencyHint | |
| CxiiRenderPipelinePassConnection | Passed to xiiRenderPipelinePass::InitializeRenderPipelinePass to inform about existing connections on each input / output pin index |
| ►CxiiRenderPipelinePassFlags | This describes the render-pipeline pass behavior and optimizations to inform the render-pipeline compiler about per-pass requirements, capabilities, and tuning hints |
| CBits | |
| CxiiRenderPipelineProfileConfig | |
| CxiiRenderPipelineResource | |
| CxiiRenderPipelineResourceDescriptor | |
| CxiiRenderPipelineResourceLoader | |
| CxiiRenderPipelineResourceLoaderConnection | |
| CxiiRenderSortingFunctions | |
| CxiiRenderTargetActivatorComponent | |
| CxiiRenderTargetFormat | |
| CxiiRenderTargets | This class can be used to define the render targets to be used by a xiiView |
| CxiiRenderToTexture2DResource | |
| CxiiRenderToTexture2DResourceDescriptor | |
| CxiiRenderViewContext | |
| ►CxiiRenderWorld | |
| CCameraConfig | |
| CxiiRenderWorldExtractionEvent | |
| CxiiRenderWorldRenderEvent | |
| CxiiResetTransformComponent | This component sets the local transform of its owner to known values when the simulation starts |
| CxiiResizeAndSetObjectPropertyCommand | |
| ►CxiiResource | The base class for all resources |
| CMemoryUsage | |
| CxiiResourceAccessorProperty | [internal] An implementation of xiiTypedMemberProperty that uses custom getter / setter functions to access a property |
| CxiiResourceEvent | These events may be sent by a specific xiiResource or by the xiiResourceManager |
| ►CxiiResourceFlags | The flags of a xiiResource instance |
| CBits | |
| CxiiResourceHandlePropertyAccessor | [internal] Helper class to generate accessor functions for (private) resource handle members |
| CxiiResourceHandleStreamOperations | |
| CxiiResourceLoadData | Data returned by xiiResourceTypeLoader implementations |
| CxiiResourceLoadDesc | Describes in which loading state a resource currently is, and how many different quality levels there are |
| CxiiResourceLoaderFromFile | A default implementation of xiiResourceTypeLoader for standard file loading |
| CxiiResourceLoaderFromMemory | A resource loader that is mainly used to update a resource on the fly with custom data, e.g. in an editor |
| CxiiResourceLock | Helper class to acquire and release a resource safely |
| CxiiResourceManager | The central class for managing all types derived from xiiResource |
| CxiiResourceManagerEvent | Events sent by the xiiResourceManager |
| CxiiResourceManagerState | |
| CxiiResourceManagerWorkerDataLoad | [internal] Worker task for loading resources (typically from disk) |
| CxiiResourceManagerWorkerUpdateContent | [internal] Worker task for uploading resource data. Depending on the resource type, this may get scheduled to run on the main thread or on any thread |
| CxiiResourceTypeLoader | Base class for all resource loaders |
| CxiiResourceUpdateMsgToEngine | |
| CxiiRestoreResourceMsgToEngine | |
| CxiiRestPoseAnimNode | |
| CxiiResult | Default enum for returning failure or success, instead of using a bool |
| CxiiRootMotionMode | |
| CxiiRootMotionSource | |
| CxiiRootRotationAnimNode | |
| CxiiRopeRenderComponent | |
| ►CxiiRopeSimulator | A simple simulator for swinging and hanging ropes |
| CNode | |
| CxiiRotateGizmo | |
| CxiiRotateGizmoEditTool | |
| CxiiRotorComponent | Applies a rotation to the game object that it is attached to |
| ►CxiiRTTI | This class holds information about reflected types. Each instance represents one type that is known to the reflection system |
| ►CForEachOptions | |
| CBits | |
| CxiiRTTIAllocator | The interface for an allocator that creates instances of reflected types |
| CxiiRttiConverterContext | |
| CxiiRttiConverterObject | |
| CxiiRttiConverterReader | |
| CxiiRttiConverterWriter | |
| CxiiRTTIDefaultAllocator | Default implementation of xiiRTTIAllocator that allocates instances via the given allocator |
| ►CxiiRttiMappedObjectFactory | A factory that creates the closest matching objects according to the passed type |
| CEvent | |
| CxiiRTTINoAllocator | Dummy Allocator for types that should not be allocatable through the reflection system |
| CxiiRttiTypeStringAttribute | Attribute that turns a string property into a selector for an RTTI type |
| CxiiSampleAnimClipAnimNode | |
| CxiiSampleAnimClipSequenceAnimNode | |
| CxiiSampleBlendSpace1DAnimNode | |
| CxiiSampleBlendSpace2DAnimNode | |
| CxiiSampleFrameAnimNode | |
| CxiiSaveDocumentTask | |
| CxiiSaveProfilingResponseToEditor | |
| CxiiScaleGizmo | |
| CxiiScaleGizmoEditTool | |
| CxiiScene2Document | |
| CxiiScene2LayerEvent | |
| CxiiSceneAction | |
| CxiiSceneActions | |
| CxiiSceneContext | |
| ►CxiiSceneDocument | |
| CSelectionHistory | |
| CxiiSceneDocumentManager | |
| CxiiSceneDocumentRoot | |
| CxiiSceneDocumentSettings | |
| CxiiSceneDocumentSettingsBase | |
| CxiiSceneExportModifier | |
| CxiiSceneExportModifier_RemoveCommentComponents | |
| CxiiSceneExportModifier_RemovePathNodeComponents | |
| CxiiSceneExportModifier_RemoveShapeIconComponents | |
| CxiiSceneGizmoActions | |
| CxiiSceneLayer | |
| CxiiSceneLayerBase | |
| CxiiSceneLoadUtility | This class allows to load a scene in the background and switch to it, once loading has finished |
| CxiiSceneObjectManager | |
| CxiiScenePreferencesUser | |
| CxiiSceneSelectionContext | Custom selection context for the scene to allow switching the active layer if an object is clicked that is in a different layer then the active one |
| CxiiSceneViewContext | |
| CxiiSceneViewPerspective | |
| CxiiScopedCFRef | Helper class to release references of core foundation objects correctly |
| CxiiScopedRefPointer | Stores a pointer to a reference counted object and automatically increases / decreases the reference count |
| CxiiScopeExit | |
| CxiiScreen | Provides functionality to detect available monitors |
| CxiiScreenInfo | Describes the properties of a screen |
| CxiiScriptableFunctionAttribute | Attribute to mark a function up to be exposed to the scripting system. Arguments specify the names of the function parameters |
| CxiiScriptAllocator | |
| CxiiScriptBaseClassFunctionAttribute | Add this attribute to a script function to mark it as a base class function. These are functions that can be entry points to visual scripts or over-writable functions in script languages like e.g. typescript |
| CxiiScriptClassResource | |
| CxiiScriptComponent | |
| ►CxiiScriptCoroutine | Base class of script coroutines |
| ►CResult | |
| CState | |
| CxiiScriptCoroutine_MoveTo | |
| CxiiScriptCoroutine_TweenProperty | |
| CxiiScriptCoroutine_Wait | |
| CxiiScriptCoroutineCreationMode | Mode that decides what should happen if a new coroutine is created while there is already another coroutine running with the same name on a given instance |
| CxiiScriptCoroutineFunctionProperty | A function property that creates an instance of the given coroutine type and starts it immediately |
| CxiiScriptCoroutineHandle | A handle to a script coroutine which can be used to determine whether a coroutine is still running even after the underlying coroutine object has already been deleted |
| CxiiScriptCoroutineMessageHandler | A message handler that creates an instance of the given coroutine type and starts it immediately |
| CxiiScriptCoroutineRTTI | A coroutine type that stores a custom allocator |
| CxiiScriptExtensionAttribute | Add this attribute to a class to add script functions to the szTypeName class. This might be necessary if the specified class is not reflected or to separate script functions from the specified class |
| CxiiScriptExtensionClass_CVar | |
| CxiiScriptExtensionClass_Debug | Helper class to expose debug rendering to scripting |
| CxiiScriptExtensionClass_Log | |
| CxiiScriptExtensionClass_Physics | |
| CxiiScriptExtensionClass_Prefabs | |
| CxiiScriptExtensionClass_Spatial | |
| CxiiScriptFunctionProperty | |
| CxiiScriptInstance | |
| CxiiScriptMessageDesc | |
| CxiiScriptMessageHandler | |
| CxiiScriptRTTI | |
| ►CxiiScriptWorldModule | |
| CFunctionContext | |
| CxiiSearchPatternFilter | A small helper class to implement a simple search pattern filter that can contain multiple parts |
| CxiiSelectedCurveCP | |
| CxiiSelectedGameObject | |
| CxiiSelectedObjectsContext | Stores a list of game objects that should get highlighted by the renderer |
| CxiiSelectedObjectsExtractor | An extractor that can be instantiated in a render pipeline, to define manually which objects should be rendered with a selection outline |
| CxiiSelectedObjectsExtractorBase | |
| CxiiSelectionAction | |
| CxiiSelectionActions | |
| CxiiSelectionContext | |
| CxiiSelectionEntry | |
| CxiiSelectionHighlightPass | |
| ►CxiiSelectionManager | Selection Manager stores a set of selected document objects |
| CStorage | |
| CxiiSelectionManagerEvent | |
| CxiiSemaphore | A semaphore is used to synchronize threads, similar to a mutex (see xiiMutex) |
| CxiiSendEventAnimNode | |
| CxiiSensorComponent | Base class for sensor components that can be used for AI perception like vision or hearing |
| CxiiSensorConeComponent | |
| CxiiSensorCylinderComponent | |
| CxiiSensorSphereComponent | |
| CxiiSensorWorldModule | |
| CxiiSeparatedBilateralBlurPass | Depth aware blur on input and writes it to an output buffer of the same format |
| CxiiSerializationContext | Base class for serialization contexts. A serialization context can be used to add high level logic to serialization, e.g. de-duplicating objects |
| CxiiSerializedBlock | |
| CxiiSet | |
| ►CxiiSetBase | A set container that only stores whether an element resides in it or not. Similar to STL::set |
| CIteratorBase | Base class for all iterators |
| CxiiSetBlackboardBoolAnimNode | |
| CxiiSetBlackboardNumberAnimNode | |
| CxiiSetColorMode | Describes how a color should be applied to another color |
| CxiiSetObjectPropertyCommand | |
| CxiiSetPropertyAccessor | |
| CxiiSettingsComponent | Base class for settings components, of which only one per type should exist in each world |
| CxiiSettingsComponentManager | A component manager that does no update at all on components and expects only a single instance to be created per world |
| CxiiSetupProjectMsgToEngine | |
| ►CxiiShaderBindFlags | |
| CBits | |
| CxiiShaderBool | A wrapper class that converts a bool into the correct data layout for shaders |
| CxiiShaderCompilerApplication | |
| CxiiShaderCompilerSPIRV | |
| CxiiShaderMat3 | A wrapper class that converts a xiiMat3 into the correct data layout for shaders |
| CxiiShaderMat4 | A wrapper class that converts a xiiMat4 into the correct data layout for shaders |
| CxiiShaderPermutationResource | |
| CxiiShaderPermutationResourceDescriptor | |
| CxiiShaderPermutationResourceLoader | |
| CxiiShaderPermutationUtilities | |
| CxiiShaderResource | |
| CxiiShaderResourceDescriptor | |
| CxiiShaderTransform | A wrapper class that converts a xiiTransform into the correct data layout for shaders |
| CxiiShaderTypeRegistry | |
| ►CxiiShaderUtilities | Provides shader utilities through static methods |
| CxiiBuiltinShader | |
| CxiiShadowPool | |
| CxiiShapeIconComponent | This is a dummy component that the editor creates on all 'empty' nodes for the sole purpose to render a shape icon and enable picking |
| CxiiSharedPtr | A Shared ptr manages a shared object and destroys that object when no one references it anymore. The managed object must derive from xiiRefCounted |
| CxiiShutdownProcessMsgToEngine | Sent to remote processes to shut them down. Local processes are simply killed through QProcess::close, but remote processes have to close themselves |
| CxiiSimdBBox | |
| CxiiSimdBBoxd | |
| CxiiSimdBBoxSphere | |
| CxiiSimdBBoxSphered | |
| CxiiSimdBSphere | |
| CxiiSimdBSphered | |
| CxiiSimdDouble | |
| CxiiSimdFloat | |
| CxiiSimdMat4d | A 4x4 matrix class |
| CxiiSimdMat4f | A 4x4 matrix class |
| CxiiSimdMath | |
| CxiiSimdPerlinNoise | |
| CxiiSimdQuat | |
| CxiiSimdQuatd | |
| CxiiSimdRandom | Noise based random number generator that generates 4 pseudo random values at once |
| CxiiSimdTransform | |
| CxiiSimdTransformd | |
| CxiiSimdVec4b | |
| CxiiSimdVec4d | A 4-component SIMD vector class |
| CxiiSimdVec4f | A 4-component SIMD vector class |
| CxiiSimdVec4i | A SIMD 4-component vector class of signed 32b integers |
| CxiiSimdVec4u | A SIMD 4-component vector class of unsigned 32b integers |
| CxiiSimpleAnimationComponent | Plays a single animation clip on an animated mesh |
| CxiiSimpleAssetDocument | |
| CxiiSimpleConfigMsgToEngine | |
| CxiiSimpleDocumentConfigMsgToEditor | |
| CxiiSimpleDocumentConfigMsgToEngine | |
| CxiiSimpleDocumentObjectManager | |
| CxiiSimpleRenderPass | A very basic render pass that renders into the color target |
| CxiiSimpleWindComponent | |
| CxiiSimpleWindWorldModule | |
| CxiiSimplifiedDataCPU | |
| CxiiSimplifiedDataExtractor | |
| CxiiSimplifiedDataGPU | |
| CxiiSimplifiedDataProvider | |
| CxiiSimulationSettingsMsgToEngine | |
| CxiiSingleCurveData | |
| CxiiSingletonRegistrar | [internal] Helper class to implement xiiSingletonRegistry and XII_DECLARE_SINGLETON |
| ►CxiiSingletonRegistry | XiiSingletonRegistry knows about all singleton instances of classes that use XII_DECLARE_SINGLETON |
| CSingletonEntry | |
| CxiiSIUnitOfTime | |
| CxiiSizeTemplate | A simple size class templated on the type for width and height |
| CxiiSizeToType | Helper struct to get a storage type from a size in byte |
| CxiiSkeleton | The skeleton class encapsulates the information about the joint structure for a model |
| CxiiSkeletonAction | |
| CxiiSkeletonActions | |
| CxiiSkeletonAssetDocument | |
| CxiiSkeletonAssetDocumentGenerator | |
| CxiiSkeletonAssetDocumentManager | |
| CxiiSkeletonAssetEvent | |
| ►CxiiSkeletonBuilder | The skeleton builder class provides the means to build skeleton instances from scratch. This class is not necessary to use skeletons, usually they should be deserialized from data created by the tools |
| CBuilderJoint | |
| ►CxiiSkeletonComponent | Uses debug rendering to visualize various aspects of an animation skeleton |
| CAngleShape | |
| CBoxShape | |
| CCapsuleShape | |
| CConeLimitShape | |
| CCylinderShape | |
| CSphereShape | |
| CxiiSkeletonComponentDragDropHandler | |
| CxiiSkeletonContext | |
| CxiiSkeletonJoint | Describes a single joint. The transforms of the joints are in their local space and thus need to be correctly multiplied with their parent transforms to get the final transform |
| CxiiSkeletonJointGeometryType | What shape is used to approximate a bone's geometry |
| CxiiSkeletonJointType | What type of physics constraint to use for a bone |
| CxiiSkeletonPoseComponent | Used in conjunction with a xiiAnimatedMeshComponent to set a specific pose for the animated mesh |
| CxiiSkeletonPoseComponentManager | |
| CxiiSkeletonPoseMode | Which pose to apply to an animated mesh |
| CxiiSkeletonResource | |
| CxiiSkeletonResourceDescriptor | |
| CxiiSkeletonResourceGeometry | |
| CxiiSkeletonViewContext | |
| CxiiSkinnedMeshRenderData | |
| CxiiSkinnedMeshRenderer | Implements rendering of skinned meshes |
| CxiiSkinningState | |
| CxiiSkyBoxComponent | |
| CxiiSkyLightComponent | |
| CxiiSkyRenderPass | A forward render pass that renders all sky objects into the color target |
| CxiiSliderAction | An action that represents an integer value within a fixed range, and gets displayed as a slider |
| CxiiSliderComponent | Applies a sliding transform to the game object that it is attached to |
| CxiiSmallArray | |
| CxiiSmallArrayBase | Implementation of a dynamically growing array with in-place storage and small memory overhead |
| CxiiSmcDescription | |
| CxiiSmcSubMesh | |
| CxiiSmcTriangle | |
| CxiiSnapProvider | |
| CxiiSnapProviderEvent | |
| CxiiSorting | This class provides implementations of different sorting algorithms |
| CxiiSoundInterface | |
| CxiiSourceFormat | |
| CxiiSourcePass | |
| CxiiSpatialAnchorComponent | |
| ►CxiiSpatialData | |
| CCategory | |
| ►CFlags | |
| CBits | |
| CxiiSpatialDataHandle | |
| ►CxiiSpatialSystem | |
| CQueryParams | |
| CxiiSpatialSystem_RegularGrid | |
| CxiiSpawnBoxComponent | This component spawns prefabs inside a box |
| ►CxiiSpawnBoxComponentFlags | |
| CBits | |
| CxiiSpawnComponent | |
| ►CxiiSpawnComponentFlags | |
| CBits | |
| CxiiSphereGizmo | |
| CxiiSphereManipulatorAdapter | |
| CxiiSphereManipulatorAttribute | |
| CxiiSphereReflectionProbeComponent | Sphere reflection probe component |
| CxiiSphereReflectionProbeComponentManager | |
| CxiiSphereVisualizerAdapter | |
| CxiiSphereVisualizerAttribute | |
| CxiiSpotLightComponent | The standard spot light component. This component represents spot lights with various properties (e.g. a projected texture, range, spot angle, etc.) |
| CxiiSpotLightRenderData | The render data object for spot lights |
| CxiiSpotLightVisualizerAdapter | |
| CxiiSpotLightVisualizerAttribute | A special visualizer attribute for spot lights |
| CxiiSpriteBlendMode | |
| CxiiSpriteComponent | |
| CxiiSpriteRenderData | |
| CxiiSpriteRenderer | Implements rendering of sprites |
| CxiiStackAllocator | |
| CxiiStackTracer | Helper class to capture the current stack and print a captured stack |
| CxiiStageSpaceComponent | Singleton to set the type of stage space and its global transform in the world |
| ►CxiiStandardJSONWriter | Implements a standard compliant JSON writer, all numbers are output as double values |
| CCommaWriter | |
| CJSONState | |
| CxiiStandardMenus | |
| ►CxiiStandardMenuTypes | |
| CBits | |
| CxiiStartup | The startup system makes sure to initialize and shut down all known subsystems in the proper order |
| CxiiStartupStage | Describes the different stages during startup and shutdown |
| CxiiStateMachine_SetInitialStateCommand | |
| CxiiStateMachineAssetDocument | |
| CxiiStateMachineAssetManager | |
| CxiiStateMachineComponent | A component that holds a xiiStateMachineInstance using the xiiStateMachineDescription from the resource assigned to this component |
| CxiiStateMachineComponentManager | |
| CxiiStateMachineConnection | A connection that represents a state machine transition. Since we can't chose different connection types in the Editor we allow the user to switch the type in the properties |
| CxiiStateMachineContext | |
| CxiiStateMachineDescription | The state machine description defines the structure of a state machine like e.g. what states it has and how to transition between them. Once an instance is created from a description it is not allowed to change the description afterwards |
| CxiiStateMachineInstance | The state machine instance represents the actual state machine. Typically it is created from a description but for small use cases it can also be used without a description |
| CxiiStateMachineLogicOperator | An enum that represents the operator of a comparison |
| CxiiStateMachineNode | A node that represents a state machine state. We don't use xiiStateMachineState directly to allow the user to switch the type in the properties similar to what we do with transitions |
| CxiiStateMachineNodeAny | A node that represents "any" state machine state. This can be used if a transition with the same conditions is possible from any other state in the state machine. Instead of creating many connections with the same properties an "any" state can be used to make the graph much easier to read and to maintain |
| CxiiStateMachineNodeBase | Base class for nodes in the state machine graph |
| CxiiStateMachineNodeManager | |
| CxiiStateMachinePin | |
| CxiiStateMachineResource | |
| CxiiStateMachineState | Base class for a state in a state machine |
| CxiiStateMachineState_Compound | A state machine state implementation that combines multiple sub states into one |
| CxiiStateMachineState_Empty | |
| CxiiStateMachineState_NestedStateMachine | A state machine state implementation that represents another state machine nested within this state. This can be used to build hierarchical state machines |
| CxiiStateMachineState_Script | A state machine state implementation that can be scripted using e.g. visual scripting |
| CxiiStateMachineState_ScriptBaseClassFunctions | |
| CxiiStateMachineState_SendMsg | A state machine state that sends a xiiMsgStateMachineStateChanged on state enter or exit to the owner of the state machine instance. Currently only works for xiiStateMachineComponent |
| CxiiStateMachineState_SwitchObject | A state machine state that sets the enabled flag on a game object and disables all other objects in the same group |
| CxiiStateMachineTransition | Base class for a transition in a state machine. The target state of a transition is automatically set once its condition has been met |
| CxiiStateMachineTransition_BlackboardConditions | A state machine transition implementation that checks the instance's blackboard for the given conditions |
| CxiiStateMachineTransition_Compound | A state machine transition implementation that combines multiple sub transition into one |
| CxiiStateMachineTransition_Timeout | A state machine transition implementation that triggers after the given time |
| CxiiStateMachineTransition_TransitionEvent | A state machine transition implementation that triggers when a 'transition event' is sent |
| CxiiStateMap | A simple registry that stores name/value pairs of types that are common to store game state |
| CxiiStaticAllocatorWrapper | |
| CxiiStaticArray | Wraps a C-style array, which has a fixed size at compile-time, with a more convenient interface |
| CxiiStaticBitfield | |
| CxiiStaticLinkHelper | |
| CxiiStaticRingBuffer | A ring-buffer container that will use a static array of a given capacity to cycle through elements |
| ►CxiiStats | This class holds a simple map that maps strings (keys) to strings (values), which represent certain stats |
| CStatsEventData | The event data that is broadcast whenever a stat is changed |
| CxiiStatus | A xiiResult with an additional message for the reason of failure |
| CxiiStbImageFileFormats | |
| CxiiStereoTestPass | |
| CxiiStopwatch | A helper class to time the execution of code or other actions |
| CxiiStreamGroupElementRemovedEvent | |
| CxiiStreamGroupElementsClearedEvent | |
| CxiiStreamReader | Interface for binary in (read) streams |
| CxiiStreamReaderWithStats | A stream reader that wraps another stream to track how many bytes are read from it |
| CxiiStreamWriter | Interface for binary out (write) streams |
| CxiiStreamWriterWithStats | A stream writer that wraps another stream to track how many bytes are written to it |
| CxiiStringBase | Base class for strings, which implements all read-only string functions |
| CxiiStringBuilder | XiiStringBuilder is a class that is meant for creating and modifying strings |
| CxiiStringDeduplicationReadContext | This class to restore strings written to a stream using a xiiStringDeduplicationWriteContext |
| CxiiStringDeduplicationWriteContext | This class allows for automatic deduplication of strings written to a stream. To use, create an object of this type on the stack, call Begin() and use the returned xiiStreamWriter for subsequent serialization operations. Call End() once you want to finish writing deduplicated strings. For a sample see StreamOperationsTest.cpp |
| CxiiStringIterator | STL forward iterator used by all string classes. Iterates over unicode characters. The iterator starts at the first character of the string and ends at the address beyond the last character of the string |
| CxiiStringReverseIterator | STL reverse iterator used by all string classes. Iterates over unicode characters. The iterator starts at the last character of the string and ends at the address before the first character of the string |
| CxiiStringUtf16 | A very simple class to convert text to Utf16 encoding |
| CxiiStringUtf32 | This class only exists for completeness |
| CxiiStringUtf8 | A small string class that converts any other encoding to Utf8 |
| CxiiStringUtils | Helper functions to work with UTF-8 strings (which include pure ASCII strings) |
| CxiiStringView | XiiStringView represent a read-only sub-string of a larger string, as it can store a dedicated string end position. It derives from xiiStringBase and thus provides a large set of functions for search and comparisons |
| CxiiStringWChar | A very simple string class that should only be used to temporarily convert text to the OSes native wchar_t convention (16 or 32 Bit) |
| CxiiSubAsset | Information about an asset or sub-asset |
| CxiiSubAssetData | |
| CxiiSubSystem | Base class for all subsystems |
| CxiiSuffixAttribute | Used for any property shown as a line edit (int, float, vector etc) |
| CxiiSurfaceAssetDocument | |
| CxiiSurfaceAssetDocumentManager | |
| CxiiSurfaceInteraction | |
| CxiiSurfaceInteractionAlignment | |
| CxiiSurfaceResource | |
| CxiiSurfaceResourceDescriptor | |
| CxiiSurfaceResourceEvent | |
| CxiiSwitchBoneWeightsAnimNode | |
| CxiiSwitchPoseAnimNode | |
| CxiiSwizzle | |
| CxiiSyncWithProcessMsgToEditor | |
| CxiiSyncWithProcessMsgToEngine | |
| CxiiSystemInformation | The system configuration class encapsulates information about the system the application is running on |
| CxiiTag | The tag class stores the necessary lookup information for a single tag which can be used in conjunction with the tag set |
| CxiiTagRegistry | The tag registry for tags in tag sets |
| ►CxiiTagSetTemplate | A dynamic collection of tags featuring fast lookups |
| CIterator | Allows to iterate over all tags in this set |
| CxiiTagSetWidgetAttribute | Add this attribute to a tag set member property to make it use the tag set editor and define the categories it will use as a ; separated list of category names |
| CxiiTargetPass | |
| CxiiTask | Base class for custom tasks |
| CxiiTaskGroup | |
| CxiiTaskGroupDependency | |
| CxiiTaskGroupID | Given out by xiiTaskSystem::CreateTaskGroup to identify a task group |
| CxiiTaskPriority | Describes the priority with which to execute a task |
| ►CxiiTaskSystem | This system allows to automatically distribute tasks onto a number of worker threads |
| CTaskData | |
| CxiiTaskSystemState | |
| CxiiTaskSystemThreadState | |
| CxiiTaskWorkerInfo | |
| CxiiTaskWorkerThread | |
| ►CxiiTelemetry | |
| CTelemetryEventData | |
| CxiiTelemetryMessage | |
| CxiiTempHashedString | A class to use together with xiiHashedString for quick comparisons with temporary strings that need not be stored further |
| CxiiTemporaryAttribute | A property attribute that indicates that the property is not to be serialized and whatever it points to only exists temporarily while running or in editor |
| CxiiTexCompareDesc | Input options for xiiTexComparer |
| CxiiTexComparer | Compares two images and generates various outputs |
| ►CxiiTexConv | |
| CKeyEnumValuePair | |
| CxiiTexConvBumpMapFilter | Defines which filter kernel is used to approximate the x/y bump map gradients |
| CxiiTexConvChannelMapping | |
| CxiiTexConvChannelValue | Defines which channel of another texture to read to get a value |
| CxiiTexConvCompressionMode | |
| CxiiTexConvDesc | |
| CxiiTexConvMipmapMode | |
| CxiiTexConvMode | |
| CxiiTexConvOutputType | |
| CxiiTexConvProcessor | |
| CxiiTexConvSliceChannelMapping | |
| CxiiTexConvTargetPlatform | |
| CxiiTexConvUsage | |
| CxiiTexFormat | |
| CxiiTexture2DChannelMappingEnum | |
| CxiiTexture2DResolution | |
| CxiiTexture2DResource | |
| CxiiTexture2DResourceDescriptor | Use this descriptor in calls to xiiResourceManager::CreateResource<xiiTexture2DResource> to create textures from data in memory |
| CxiiTexture3DResource | |
| CxiiTexture3DResourceDescriptor | Use this descriptor in calls to xiiResourceManager::CreateResource<xiiTexture3DResource> to create textures from data in memory |
| CxiiTextureAssetActions | |
| CxiiTextureAssetDocument | |
| CxiiTextureAssetDocumentGenerator | |
| CxiiTextureAssetDocumentManager | |
| CxiiTextureAssetProfileConfig | |
| CxiiTextureAssetProperties | |
| ►CxiiTextureAtlasCreationDesc | |
| CItem | |
| CLayer | |
| ►CxiiTextureAtlasRuntimeDesc | |
| CItem | |
| CxiiTextureChannelMode | |
| CxiiTextureChannelModeAction | |
| CxiiTextureContext | |
| CxiiTextureCubeAssetDocument | |
| CxiiTextureCubeAssetDocumentGenerator | |
| CxiiTextureCubeAssetDocumentManager | |
| CxiiTextureCubeAssetProperties | |
| CxiiTextureCubeChannelMappingEnum | |
| CxiiTextureCubeContext | |
| CxiiTextureCubeResource | |
| CxiiTextureCubeResourceDescriptor | Use this descriptor in calls to xiiResourceManager::CreateResource<xiiTextureCubeResource> to create textures from data in memory |
| CxiiTextureCubeViewContext | |
| CxiiTextureFilterSetting | |
| CxiiTextureLodSliderAction | |
| ►CxiiTexturePacker | |
| CTexture | |
| ►CxiiTextureResourceLoader | |
| CLoadedData | |
| CxiiTextureUtils | |
| CxiiTextureViewContext | |
| CxiiTgaFileFormat | |
| CxiiThisIsAString | Base class which marks a class as containing string data |
| CxiiThread | This class is the base class for platform independent long running threads |
| CxiiThreadEvent | |
| CxiiThreadSignal | Waiting on a thread signal puts the waiting thread to sleep. Other threads can wake it up by raising the signal |
| CxiiThreadUtils | Contains general thread functions |
| CxiiThreadWithDispatcher | This class is the base class for threads which need dispatching of calls |
| CxiiTime | The time class encapsulates a double value storing the time in seconds |
| CxiiTimedDeathComponent | This component deletes the object it is attached to after a timeout |
| ►CxiiTimestamp | The timestamp class encapsulates a date in time as microseconds since Unix epoch |
| CCompareMode | |
| CxiiTimeStepSmoothing | Base class for all time step smoothing algorithms |
| CxiiTitleAttribute | Used for dynamic titles of visual script nodes. E.g. "Set Bool Property '{Name}'" will allow the title to by dynamic by reading the current value of the 'Name' property |
| CxiiToggleWorldSpaceGizmo | |
| CxiiToken | Represents one piece of tokenized text in a document |
| ►CxiiTokenizedFileCache | This object caches files in a tokenized state. It can be shared among xiiPreprocessor instances to improve performance when they access the same files |
| CFileData | |
| CxiiTokenizer | Takes text and splits it up into xiiToken objects. The result can be used for easier parsing |
| CxiiTokenType | Describes which kind of token a xiiToken is |
| CxiiTonemapPass | |
| CxiiToolsProject | |
| CxiiToolsProjectEvent | |
| CxiiToolsProjectRequest | |
| CxiiToolsReflectionUtils | Helper functions for handling reflection related operations |
| CxiiToolsSerializationUtils | Helper functions for serializing data |
| CxiiToolsTag | |
| CxiiToolsTagRegistry | |
| CxiiTraitInt | Type traits |
| CxiiTransformComponent | Base class for some components that modify an object's transform |
| ►CxiiTransformComponentFlags | Internal flags for the current state of a transform component |
| CBits | |
| ►CxiiTransformFlags | |
| CBits | |
| CxiiTransformGizmoAction | |
| CxiiTransformGizmoActions | |
| CxiiTransformManipulatorAdapter | |
| CxiiTransformManipulatorAttribute | |
| CxiiTransformPreservation | Defines during re-parenting what transform is going to be preserved |
| CxiiTransformResult | |
| CxiiTransformStatus | |
| CxiiTransformTemplate | A class that represents position, rotation and scaling via a position vector, a quaternion and a scale vector |
| CxiiTranslateGizmo | |
| CxiiTranslateGizmoAction | |
| CxiiTranslateGizmoEditTool | |
| CxiiTranslationLookup | Handles looking up translations for strings |
| CxiiTranslator | Base class to translate one string into another |
| CxiiTranslatorFromFiles | Loads translations from files. Each translator can have different search paths, but the files to be loaded are the same for all of them |
| CxiiTranslatorLogMissing | Outputs a 'Missing Translation' warning the first time a string translation is requested. Otherwise always returns nullptr, allowing the next translator to take over |
| CxiiTranslatorMakeMoreReadable | Returns the same string that is passed into it, but strips off class names and separates the text at CamelCase boundaries |
| CxiiTranslatorPassThrough | Just returns the same string that is passed into it. Can be used to display the actually untranslated strings |
| CxiiTranslatorStorage | Can store translated strings and all translation requests will come from that storage. Returns nullptr if the requested string is not known |
| CxiiTransparentForwardRenderPass | A forward render pass that renders all transparent objects into the color target |
| CxiiTreeNode | |
| CxiiTriggerDelayModifierComponent | Handles xiiMsgTriggerTriggered events and sends new messages after a delay |
| CxiiTriggerState | |
| CxiiTwoBoneIKComponent | Adds inverse kinematics for a chain of three joints (two-bones) of an animated mesh to reach a target position |
| CxiiTypedArrayProperty | Do not cast into this class or any of its derived classes, use xiiTypedArrayProperty instead |
| CxiiTypedArrayProperty< const char * > | Specialization of xiiTypedArrayProperty to retain the pointer in const char* |
| CxiiTypedComponentHandle | A typed handle to a component |
| CxiiTypedConstantProperty | The base class for all typed member properties. Ie. once the type of a property is determined, it can be cast to the proper version of this |
| CxiiTypedCVar | [internal] Helper class to implement xiiCVarInt, xiiCVarFlag, xiiCVarBool and xiiCVarString |
| CxiiTypedEnumProperty | [internal] Base class for enum / bitflags properties that already defines the type |
| CxiiTypedFunctionProperty | |
| CxiiTypedMapProperty | |
| CxiiTypedMemberProperty | The base class for all typed member properties. I.e. once the type of a property is determined, it can be cast to the proper version of this |
| CxiiTypedMemberProperty< const char * > | Specialization of xiiTypedMemberProperty for const char* |
| CxiiTypedObject | Defines a reference to an immutable object owned by a xiiVariant |
| CxiiTypedPointer | A typed raw pointer |
| CxiiTypedResourceHandle | The xiiTypedResourceHandle controls access to a xiiResource |
| CxiiTypedScriptCoroutine | Base class of coroutines which are implemented in C++ to allow automatic unpacking of the arguments from variants |
| CxiiTypedSetProperty | Do not cast into this class or any of its derived classes, use xiiAbstractSetProperty instead |
| CxiiTypedSetProperty< const char * > | Specialization of xiiTypedArrayProperty to retain the pointer in const char* |
| ►CxiiTypeFlags | Flags that describe a reflected type |
| CBits | |
| CxiiTypelessResourceHandle | The typeless implementation of resource handles. A typed interface is provided by xiiTypedResourceHandle |
| CxiiTypeTraits | |
| CxiiTypeVersionInfo | A class that overlaps xiiReflectedTypeDescriptor with the properties needed for patching |
| CxiiTypeVersionReadContext | Use this class to restore type versions written to a stream using a xiiTypeVersionWriteContext |
| CxiiTypeVersionWriteContext | This class allows for writing type versions to a stream in a centralized place so that each object doesn't need to write its own version manually |
| CxiiTypeWidgetAttribute | Derive from this class if you want to define an attribute that replaces the property type widget |
| ►CxiiUnicodeUtils | Helper functions to work with Unicode |
| CUtfInserter | [internal] Small helper class to append bytes to some arbitrary container. Used for Utf8 string building |
| CxiiUniquePtr | A Unique ptr manages an object and destroys that object when it goes out of scope. It is ensure that only one unique ptr can manage the same object |
| CxiiUnlinkPrefabCommand | |
| CxiiUpdateRate | |
| CxiiUpdateReflectionTypeMsgToEditor | |
| CxiiUpdateTask | |
| CxiiUtilityPipelinePass | |
| CxiiUuid | This data type is the abstraction for 128-bit Uuid (also known as GUID) instances |
| CxiiVarianceTypeAngle | |
| CxiiVarianceTypeAngled | |
| CxiiVarianceTypeBaseDouble | |
| CxiiVarianceTypeBaseFloat | |
| CxiiVarianceTypeDouble | |
| CxiiVarianceTypeFloat | |
| CxiiVarianceTypeTime | |
| ►CxiiVariant | XiiVariant is a class that can store different types of variables, which is useful in situations where it is not clear up front, which type of data will be passed around |
| CStringWrapper | Helper struct to wrap a string pointer |
| CxiiVariantAdapter | Used to implicitly retrieve any value from a xiiVariant to be used as a function argument using the assignment rules outlined in xiiAbstractFunctionProperty::Execute |
| CxiiVariantAdapter< const char *, const char *, 1, 0 > | |
| CxiiVariantAdapter< T, C, 1, 0 > | |
| CxiiVariantAdapter< T, C, 1, 1 > | |
| CxiiVariantAdapter< T, xiiBitflags< S >, 0, 0 > | |
| CxiiVariantAdapter< T, xiiBitflags< S >, 0, 1 > | |
| CxiiVariantAdapter< T, xiiEnum< S >, 0, 0 > | |
| CxiiVariantAdapter< T, xiiEnum< S >, 0, 1 > | |
| CxiiVariantAdapter< T, xiiStringView, 1, 0 > | |
| CxiiVariantAdapter< T, xiiVariant, 1, 0 > | |
| CxiiVariantAdapter< T, xiiVariant, 1, 1 > | |
| CxiiVariantAdapter< T, xiiVariantArray, 0, 0 > | |
| CxiiVariantAdapter< T, xiiVariantArray, 0, 1 > | |
| CxiiVariantAdapter< T, xiiVariantDictionary, 0, 0 > | |
| CxiiVariantAdapter< T, xiiVariantDictionary, 0, 1 > | |
| CxiiVariantAssignmentAdapter | Used to automatically assign any value to a xiiVariant using the assignment rules outlined in xiiAbstractFunctionProperty::Execute |
| CxiiVariantAssignmentAdapter< T, C, 1 > | |
| CxiiVariantAssignmentAdapter< T, xiiBitflags< S >, 0 > | |
| CxiiVariantAssignmentAdapter< T, xiiEnum< S >, 0 > | |
| CxiiVariantAssignmentAdapter< T, xiiVariantArray, 0 > | |
| CxiiVariantAssignmentAdapter< T, xiiVariantDictionary, 0 > | |
| CxiiVariantClass | |
| CxiiVariantHelper | |
| CxiiVariantType | This enum describes the type of data that is currently stored inside the variant |
| CxiiVariantTypeDeduction | A helper struct to convert the C++ type, which is passed as the template argument, into one of the xiiVariant::Type enum values |
| CxiiVariantTypeInfo | Defines functions to allow the full feature set of xiiVariant to be used |
| CxiiVariantTypeInfoT | Helper template used by XII_DEFINE_CUSTOM_VARIANT_TYPE |
| CxiiVariantTypeRegistry | Variant type registry allows for custom variant type infos to be accessed |
| CxiiVec2Template | A 2-component vector class |
| CxiiVec3Template | A 3-component vector class |
| CxiiVec4Template | A 4-component vector class |
| CxiiVersionKey | Tuple used for identifying patches and tracking patch progression |
| CxiiVertexStreamInfo | |
| CxiiView | Encapsulates a view on the given world through the given camera and rendered with the specified RenderPipeline into the given render target setup |
| CxiiViewAction | |
| CxiiViewActions | |
| CxiiViewData | Holds view data like the viewport, view and projection matrices |
| CxiiViewDestroyedMsgToEngine | |
| CxiiViewDestroyedResponseMsgToEditor | |
| CxiiViewHandle | |
| CxiiViewHighlightMsgToEngine | |
| CxiiViewLightActions | Actions for configuring the engine view light settings |
| CxiiViewLightButtonAction | |
| CxiiViewLightSliderAction | |
| CxiiViewMarqueePickingMsgToEngine | |
| CxiiViewMarqueePickingResultMsgToEditor | |
| CxiiViewPickingMsgToEngine | |
| CxiiViewPickingResultMsgToEditor | |
| CxiiViewRedrawMsgToEngine | |
| CxiiViewRenderMode | |
| CxiiViewScreenshotMsgToEngine | |
| ►CxiiVirtualThumbStick | A Virtual Thumb-stick is an input device that transforms certain types of input (mouse / touch) into input similar to a thumb-stick on a controller |
| CCenterMode | Defines whether the thumb-stick center position is locked or relative to where the user started touching it |
| ►CFlags | |
| CBits | |
| CInput | This enum allows to select either some default input mapping or to select 'Custom' |
| COutput | Specifies which type of output the thumb-stick shall generate |
| CxiiVisibilityState | When an object is 'seen' by a view and thus tagged as 'visible', this enum describes what kind of observer triggered this |
| CxiiVisibleObjectsExtractor | |
| CxiiVisitorExecution | Used as return value of visitor functions to define whether calling function should stop or continue visiting |
| CxiiVisualizeHandComponent | |
| CxiiVisualizerAdapter | Base class for the editor side code that sets up a 'visualizer' for object properties |
| CxiiVisualizerAdapterRegistry | |
| ►CxiiVisualizerAnchor | |
| CBits | |
| CxiiVisualizerAttribute | |
| CxiiVisualizerManager | |
| CxiiVisualizerManagerEvent | |
| CxiiVisualScriptClassAssetDocument | |
| CxiiVisualScriptClassAssetManager | |
| CxiiVisualScriptClassAssetProperties | |
| CxiiVisualScriptClassResource | |
| ►CxiiVisualScriptCompiler | |
| CAstNode | |
| CCompiledFunction | |
| CCompiledModule | |
| CDataInput | |
| CDataOutput | |
| CxiiVisualScriptComponentDragDropHandler | |
| CxiiVisualScriptComponentHandle | |
| CxiiVisualScriptCoroutine | |
| CxiiVisualScriptCoroutineAllocator | |
| ►CxiiVisualScriptDataDescription | |
| ►CDataOffset | |
| CSource | |
| COffsetAndCount | |
| CxiiVisualScriptDataStorage | |
| CxiiVisualScriptDataType | Data types that are available in visual script. These are a subset of xiiVariantType |
| CxiiVisualScriptExecutionContext | |
| CxiiVisualScriptExpressionDataType | |
| CxiiVisualScriptExpressionVariable | |
| CxiiVisualScriptFunctionProperty | |
| CxiiVisualScriptGameObjectHandle | |
| ►CxiiVisualScriptGraphDescription | |
| CEmbeddedArrayOrPointer | |
| ►CExecResult | |
| CState | |
| CNode | |
| CxiiVisualScriptInstance | |
| CxiiVisualScriptInstanceData | |
| CxiiVisualScriptMessageHandler | |
| ►CxiiVisualScriptNodeDescription | |
| CType | Native node types for visual script graphs. Editor only types are not supported at runtime and will be replaced by the visual script compiler during asset transform |
| CxiiVisualScriptNodeManager | |
| ►CxiiVisualScriptNodeRegistry | |
| CNodeCreationTemplate | |
| CNodeDesc | |
| CPinDesc | |
| CxiiVisualScriptPin | |
| CxiiVisualScriptSendMessageMode | |
| CxiiVisualScriptTypeDeduction | |
| CxiiVisualScriptVariable | |
| CxiiVisualScriptVariableAttribute | |
| CxiiVisualShaderAction | |
| CxiiVisualShaderActions | |
| CxiiVisualShaderCodeGenerator | |
| CxiiVisualShaderNodeDescriptor | |
| CxiiVisualShaderNodeManager | |
| CxiiVisualShaderNodeType | |
| CxiiVisualShaderPin | |
| CxiiVisualShaderPinDescriptor | |
| CxiiVisualShaderTypeRegistry | |
| CxiiVolumeBoxComponent | |
| CxiiVolumeComponent | A volume component can hold generic values either from a blackboard template or set directly on the component |
| CxiiVolumePosition | Enum that describes where in a volume another object is located |
| CxiiVolumeSampler | A volume sampler is used to sample the registered values from volumes at a given position. It also takes care of interpolation over time of those values |
| CxiiVolumeSphereComponent | |
| CxiiVulkanTypeConversions | |
| CxiiWindow | A simple abstraction for platform specific window creation |
| CxiiWindowBase | Base class of all window classes that have a client area and a native window handle |
| CxiiWindowCreationDescription | Parameters for creating a window, such as position and resolution |
| CxiiWindowMode | Determines how the position and resolution for a window are picked |
| CxiiWindowOutputTargetBase | Base class for window output targets |
| CxiiWindowOutputTargetGAL | Creates a swapchain and keeps it up to date with the window |
| CxiiWindowOutputTargetXR | XR Window output target base implementation. Optionally wraps a companion window output target |
| CxiiWindowXR | XR Window base implementation. Optionally wraps a companion window |
| CxiiWindStrength | Defines the strength / speed of wind. Inspired by the Beaufort Scale |
| CxiiWindVolumeComponent | |
| CxiiWindVolumeConeComponent | |
| CxiiWindVolumeCylinderComponent | |
| CxiiWindVolumeCylinderMode | |
| CxiiWindVolumeSphereComponent | |
| CxiiWindWorldModuleInterface | |
| CxiiWorkerThreadType | |
| CxiiWorld | A world encapsulates a scene graph of game objects and various component managers and their components |
| CxiiWorldDesc | Describes the initial state of a world |
| ►CxiiWorldGeoExtractionUtil | A utility to gather raw geometry from a world |
| CMeshObject | |
| ►CxiiWorldModule | |
| CUpdateContext | |
| CUpdateFunctionDesc | Description of an update function that can be registered at the world |
| ►CxiiWorldModuleConfig | |
| CInterfaceImpl | |
| CxiiWorldModuleFactory | Helper class to get component type ids and create new instances of world modules from rtti |
| ►CxiiWorldReader | Reads a world description from a stream. Allows to instantiate that world multiple times in different locations and different xiiWorld's |
| CInstantiationContextBase | A context object is returned from InstantiateWorld or InstantiatePrefab if a maxStepTime greater than zero is specified |
| ►CxiiWorldRttiConverterContext | The world rtti converter context tracks created objects and is capable of also handling components / game objects. Used by the xiiIPCObjectMirror to create / destroy objects |
| CEvent | |
| CxiiWorldSettingsMsgToEngine | |
| CxiiWorldUpdatePhase | |
| CxiiWorldWriter | Stores an entire xiiWorld in a stream |
| CxiiWriteAccessorMapProperty | |
| CxiiXRConfig | |
| CxiiXRDeviceEventData | |
| ►CxiiXRDeviceFeatures | Defines features the given device supports |
| CBits | |
| CxiiXRDeviceState | A device's pose state |
| CxiiXRDeviceType | |
| CxiiXRHand | |
| CxiiXRHandBone | |
| CxiiXRHandPart | |
| CxiiXRHandTrackingInterface | XR Hand tracking interface |
| CxiiXRInputDevice | |
| CxiiXRInterface | XR singleton interface. Needs to be initialized to be used for VR or AR purposes |
| CxiiXRPoseLocation | |
| CxiiXRRemotingConnectionEventData | |
| CxiiXRRemotingConnectionState | |
| CxiiXRRemotingDisconnectReason | |
| CxiiXRRemotingInterface | XR Remoting singleton interface. Allows for streaming the XR application to a remote device |
| CxiiXRSpatialAnchorsInterface | XR spatial anchors interface |
| CxiiXRStageSpace | Defines the stage space used for the XR experience |
| CxiiXRTransformSpace | |
1.13.2