maxon Namespace Reference

Detailed Description

The maxon namespace contains all declarations of the MAXON API.

[observers_declaration]

Useful apibasemath extensions.

Namespaces

 ANIMATION
 
 APPLICATIONID
 
 APPMESSAGE
 
 APPSETTINGS
 
 ARGUMENTS
 
 ASSET
 
 ASSET_MANAGER_SETTINGS
 
 ASSET_VERSIONS
 
 ASSETMETADATA
 
 ASSETREPOSITORYPROPERTIES
 
 AssetRepositoryTypes
 
 ASSETTYPEPROPERTIES
 
 AssetTypes
 
 ATTRIBUTE
 
 ATTRIBUTEMANAGER
 
 AutoWeightAlgos
 
 AutoWeightComponents
 
 BASE64_OPTIONS
 
 BlendFunctions
 
 BLOWFISHLEGACYENDECODER_OPTIONS
 
 CATEGORY
 
 Classes
 
 CodeExchangerLanguageId
 
 ColorProfiles
 
 ColorSpaces
 
 ColorTable
 
 COMMAND
 
 CommandClasses
 
 CommandDataClasses
 
 CONVEXDECOMPOSITIONATTRIBUTES
 
 ConvexDecompositionClasses
 
 corenodes
 
 CPythonLibs
 
 CryptographyOptions
 
 CustomDataTagClasses
 
 CustomDataTagDisplayClasses
 
 CUSTOMGUI_DATATYPE
 
 CustomNodeGui
 
 DATAFORMAT
 
 DATAFORMATBASEIDS
 
 DataFormatBaseReader
 
 DataFormatBaseWriter
 
 DataFormatReaderFactories
 
 DataFormatWriterFactories
 
 DATATYPE
 
 DESCRIPTION
 
 detail
 
 details
 
 Dimensions
 
 EXCHANGE
 
 EXIFDATA
 
 FFTClasses
 
 FileFormatHandlers
 
 FILEFORMATPROPERTIES
 
 FileFormats
 
 FilterClasses
 
 FilterCommandQueueClasses
 
 FilterContextClasses
 
 FilterImageClasses
 
 FilterImageDescriptionParameters
 
 geomgraph
 
 HASH_HMAC
 
 HTTPANSWER
 
 HTTPREQUEST
 
 ImageBaseClasses
 
 IMAGEBASEPROPERTIES
 
 ImageChannelTypes
 
 ImageClasses
 
 ImageLayerClasses
 
 ImagePixelBlends
 
 ImagePixelBlendsInternal
 
 ImagePixelStorageClasses
 
 IMAGEPROPERTIES
 
 ImageSaverClasses
 
 ImageTextureClasses
 
 InterpolateTypes
 
 IODOCUMENTSETTINGS
 
 JSON_WEBSOCK
 
 LegacyCommandDataClasses
 
 Loggers
 
 LOGGERTYPEFLAGS
 
 LoggerTypes
 
 MACHINE_MESSAGE
 
 MACHINEINFO
 
 MATERIAL
 
 material
 
 MEDIAFORMAT
 
 MEDIAINPUTPROPERTIES
 
 MEDIAOUTPUTURLPROPERTIES
 
 MEDIAPROPERTIES
 
 MEDIASESSION
 
 MEDIASTREAM
 
 MemoizationTypes
 
 MODULEVERSIONINFO
 
 neighbor
 
 NETWORK
 
 NETWORKWEBSOCKETCONNECTIONPROPERTIES
 
 neutron
 
 NEUTRON
 
 NIMBUSCONTEXTGETTER
 
 NODE
 
 nodes
 
 NODESPACE
 
 NOISEPROPERTY
 
 NormalsHelper
 
 OBJECT
 
 OIDNFilterParameter
 
 ParametricTypes
 
 ParserClasses
 
 PARSERPARAMETERS
 
 PATTERN
 
 PixelFormats
 
 presetargs
 
 PresetAssetImplementations
 
 py
 
 py3
 
 PythonVms
 
 ReadArchiveClasses
 
 reflection
 
 RenderNoiseClasses
 
 rla
 
 specialtype
 
 SqlDatabaseClasses
 
 STREAMCONVERSION
 
 STREAMCONVERSIONFACTORYFLAGS
 
 StreamConversions
 
 STREAMCONVERSIONTEST
 
 STREAMFLAGS
 
 StringDecodings
 
 StringEncodings
 
 SubDataOperations
 
 SubDatas
 
 TangentSpaceNormalHelper
 
 timezone
 
 TransactionProperties
 
 UiConversions
 
 Units
 
 URLFLAGS
 
 UTF8_OPTIONS
 
 UTFTEXT_OPTIONS
 
 VectorImageClasses
 
 VirtualMachines
 
 VmDebuggerConnections
 
 WriteArchiveClasses
 

Classes

struct  Bone
 
struct  AutoWeightPointJointSelections
 
class  AutoWeightInterface
 
struct  AssetSortData
 
struct  BuildBrowserEntryData
 
class  AssetBrowserInterface
 
class  CommandAssetInterface
 
class  AssetCreationHelper
 
struct  AssetDatabaseStruct
 
class  AssetDataBasesInterface
 
class  AssetDownloadsInterface
 
class  DragAndDropDataAssetArray
 
class  KeywordAssetInterface
 
struct  BaseAssetMetaData
 
struct  CreationAssetMetaData
 
class  AssetUtilitiesInterface
 
class  WatchFolderAssetRepositoryInterface
 
struct  AssetDependencyStruct
 
class  AssetMetaDataInterface
 
class  AssetTypeInterface
 
class  AssetIdentifierInterface
 
class  AssetLinkInterface
 
class  AssetRepositoryInterface
 
class  DerivedAssetRepositoryDataInterface
 
class  AssetBaseInterface
 
class  AssetDescriptionInterface
 
class  AssetBaseWithUpdateInterface
 
class  AssetReferenceInterface
 
struct  AssetVersionValidityData
 
struct  AssetLicenseValidityData
 
class  AssetInterface
 
class  UpdatableAssetInterface
 
class  UpdatableAssetRepositoryInterface
 
class  CompactableAssetRepositoryInterface
 
class  FileAssetInterface
 
class  StoreAssetStruct
 
class  ResolveAssetDependenciesStruct
 
class  AddAssetDepencendyStruct
 
class  PresetLoadArgs
 
class  PresetSaveArgs
 
class  BasePresetAssetTypeInterface
 
class  BasePresetAssetInterface
 
class  CreatePresetAssetStruct
 
class  CategoryAssetInterface
 
class  ColorCategoryAssetInterface
 
class  DatabaseAssetInterface
 
class  DataDescriptionPresetStorageInterface
 
class  LazyLanguageStringDataDescriptionDefinitionInterface
 
class  LazyLanguageDictionaryInterface
 
class  NodeSpaceAssetInterface
 
class  PluginAssetInterface
 
class  SmartSearchAssetInterface
 
class  SubTypeAssetInterface
 
class  UrlAssetRepositoryInterface
 
class  PreviewImageData
 
class  PreviewImageCustomGui
 
class  ClassicObjectWrapper
 
class  C4DPolyObjectType
 
class  C4DPolyLineObjectType
 
class  C4DSplineObjectType
 
struct  LockTraits< ::AutoLock >
 
class  BaseBitSet
 
class  AssetCreationInterface
 
class  AssetManagerSubDialogInterface
 
class  AssetManagerInterface
 
class  CodeExchangerInterface
 
class  RendererDefaultMaterialInterface
 
class  CustomNodeGuiBase
 
class  AttributeManagerProxyInterface
 
class  CustomNodeGuiProxyInterface
 
class  DescEntryStruct
 
class  DescTranslation
 
class  ParsingErrorInterface
 
class  KeyErrorInterface
 
class  ValueErrorInterface
 
class  TypeErrorInterface
 
class  IndexErrorInterface
 
class  PythonElementBaseInterface
 
class  PythonElementEmbeddedInterface
 
class  PythonElementScriptInterface
 
class  PythonBaseList2DDetectorInterface
 
class  PyElementManagerInterface
 
class  PythonRegisteredCommandIdsInterface
 
class  UiConversionInterface
 
class  WebSocketJsonCodeExchangerInterface
 
class  CommandDataInterface
 
class  LegacyCommandDataInterface
 
class  CommandClassInterface
 
class  CommandInteractionClassInterface
 
class  CommandDescriptionClassInterface
 
class  LegacyCommandClassInterface
 
class  MigratedCommandClassInterface
 
class  CommandConversionClassInterface
 
class  CommandCacheData
 
class  CommandCacheInterface
 
class  CommandExecutionInterface
 
class  DefaultValueFunctionsHelper< const Result< COMMANDRESULT > &, ALLOW_NONCONST >
 
struct  InvocationState
 
class  CommandObserverInterface
 
class  MemoizationCacheInterface
 
struct  ABIParamType
 
struct  ABIParamType< T, typename std::enable_if< STD_IS_REPLACEMENT(enum, T)||STD_IS_REPLACEMENT(integral, T)>::type >
 
struct  ABIParamType< Block< T, STRIDED, MOVE > >
 
struct  ABIParamType< T, typename std::enable_if< STD_IS_REPLACEMENT(pointer, T)>::type >
 
struct  ABIParamType< T, typename std::enable_if< STD_IS_REPLACEMENT(reference, T)>::type >
 
struct  IsIterable
 
struct  IsIterable< T[N]>
 
class  Match
 
class  Match< Int >
 
struct  PredicateMatcher
 
struct  ValuePredicate
 
struct  ValueComparePredicate
 
struct  RepeatingPredicateMatcher
 
struct  SequenceMatcher
 
struct  IntType
 
struct  IntType< 1 >
 
struct  IntType< 2 >
 
struct  IntType< 4 >
 
struct  IntType< 8 >
 
struct  UIntType
 
struct  UIntType< 1 >
 
struct  UIntType< 2 >
 
struct  UIntType< 4 >
 
struct  UIntType< 8 >
 
struct  StandardType
 
struct  StandardType< T, true >
 
class  Block
 
class  GenericComponent
 
class  Result
 
class  ResultOk
 
class  EmptyClass
 
class  EmptyVirtualClass
 
class  SFINAEHelper
 
class  PrivateOverloadRank0
 
class  PrivateOverloadRank1
 
class  PrivateOverloadRank2
 
class  PrivateOverloadRank3
 
class  PrivateOverloadRank4
 
class  PrivateOverloadRank5
 
struct  AlwaysFalse
 
struct  And
 
struct  And< true, REST... >
 
struct  And< false, REST... >
 
struct  And<>
 
class  Protected
 
class  ConstIf
 
class  ConstIf< T, true >
 
class  InheritConst
 
class  InheritConst< T, const INHERIT_FROM >
 
class  Substitute
 
class  Substitute< T &, R >
 
class  Substitute< T &&, R >
 
struct  ParameterPack
 
struct  ParameterPack< T, REST... >
 
struct  GetSignature
 
struct  GetSignature< RET(ARGS...)>
 
struct  GetSignature< RET(*)(ARGS...)>
 
struct  GetSignature< RET(CALLABLE::*)(ARGS...)>
 
struct  GetSignature< RET(CALLABLE::*)(ARGS...) const >
 
class  CommonLValue
 
class  CommonType
 
struct  MemberDetectorHelper
 
class  EnableIfFlag
 
class  IsCompleteBase
 
class  IsComplete
 
struct  GetReferencedType
 
struct  GetReferencedType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::ReferencedType >::type >
 
struct  GetConstReferencedType
 
struct  GetConstReferencedType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::ConstReferencedType >::type >
 
struct  GetDirectlyReferencedType
 
struct  GetDirectlyReferencedType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::DirectlyReferencedType >::type >
 
struct  GetErasedType
 
struct  GetErasedType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::ErasedType >::type >
 
struct  GetDirectlyReferencedTypeCheckConstAndPtr
 
struct  IsAllocType
 
struct  IsAllocType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::IsAllocType >::type >
 
struct  IsNonvirtualInterfaceType
 
struct  IsNonvirtualInterfaceType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::NonvirtualInterfaceMarker >::type >
 
struct  IsVirtualInterfaceType
 
struct  IsVirtualInterfaceType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::InterfaceMarker >::type >
 
struct  IsInterfaceType
 
struct  IsInterfaceType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::MTable >::type >
 
struct  GetValueType
 
struct  GetValueType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::ValueType >::type >
 
struct  CheckHasBase
 
struct  CheckHasBase< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::HasBaseDetector >::type >
 
struct  GetNonConst
 
struct  GetNonConst< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::NonConst >::type >
 
struct  GetHandler
 
struct  GetHandler< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::Handler >::type >
 
class  IsReferenceClass
 
class  IsObjectReferenceClass
 
struct  IsPartiallyOrdered
 
struct  IsPartiallyOrdered< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::PartiallyOrdered >::type >
 
struct  IsTriviallyEquatable
 
struct  IsTriviallyHashable
 
struct  IsTriviallyHashable< T, decltype(T::TriviallyHashable())>
 
struct  IsZeroInitialized
 
struct  IsZeroInitialized< Generic >
 
struct  HasBaseDetector
 
struct  IsDerived
 
struct  HasErasedBase
 
struct  GenericCastMemberTrait
 
struct  GenericCastMemberTrait< const TO &, FROM, SAFE >
 
struct  GenericCastMemberTrait< const TO &, FROM &, SAFE >
 
struct  GenericCastMemberTrait< TO &, FROM &, SAFE >
 
struct  GenericCastMemberTrait< const TO *, FROM *, SAFE >
 
struct  GenericCastMemberTrait< TO *, FROM *, SAFE >
 
struct  GenericCastTrait
 
class  ByValueParam
 
class  MultiplicativePromotion
 
class  MultiplicativePromotion< T1, T2, false >
 
class  MultiplicativePromotion< GenericArithmetic, T, true >
 
class  MultiplicativePromotion< T, GenericArithmetic, true >
 
class  MultiplicativePromotion< GenericArithmetic, GenericArithmetic, true >
 
class  Dereference
 
class  BaseRef
 
class  Dereference< BaseRef< T, HANDLER >, false >
 
class  ForEach
 
class  UnitType
 
class  GenericArithmetic
 
class  ThreadReferencedError
 
struct  ValueKindHelper
 
struct  ValueKindHelper< T *, REF >
 
struct  ValueKindHelper< T, true >
 
struct  ValueKindHelper< ObjectInterface, false >
 
class  GetCollectionKind
 
struct  TestForCopyFromMember
 
class  ObjectConstructor
 
class  ObjectConstructor< T, false >
 
struct  HasInit
 
struct  AlignedStorage
 
class  DefaultLValue
 
class  Application
 
class  PersistentIdGeneratorInterface
 
class  StaticArrayInterface
 
class  NonConstArray
 
class  ArrayInterface
 
class  ArrayFactory
 
class  ArrayCloneHelper
 
class  ArrayImpl
 
class  ArrayCloneHelper< ARRAY & >
 
struct  ArrayAllocatorValueType
 
class  ArrayAllocator
 
class  BlockArrayAllocator
 
class  BaseArrayAllocator
 
class  BufferedBaseArrayAllocator
 
class  ArrayMapHelper
 
class  ArrayMapHelper< K, V, true, COMPARE, ARRAY >
 
class  ArrayMap
 
class  ArrayMapSelector
 
class  ArraySet
 
class  ARWLock
 
class  ScopedARWReadLock
 
class  ScopedARWWriteLock
 
class  Atomic32
 
class  Atomic64
 
class  Atomic16
 
class  Atomic8
 
class  AtomicBool
 
class  AtomicFloatType
 
class  AtomicPtr
 
class  StrongReferenceCounter
 
class  AttributeTupleBase
 
class  AttributeTupleBase< false, CNT >
 
class  AttributeTuple
 
class  BackgroundEntryInterface
 
class  BackgroundProgressInterface
 
class  BaseArray
 
struct  GenericCastMemberTrait< BaseArray< TO >, BaseArray< FROM >, SAFE >
 
class  BaseArraySelector
 
class  BufferedBaseArraySelector
 
struct  IsZeroInitialized< BaseArray< T, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR > >
 
class  BaseBitSetIterator
 
struct  BaseListLinkPOD
 
class  BaseListLink
 
class  BaseListNodeBase
 
class  BaseListNode
 
class  BaseListNode< T, false >
 
class  BaseListNode< T, true >
 
class  BaseListNode< EmptyClass, false >
 
class  BaseListHead
 
class  BaseList
 
class  BaseListLegacyNode
 
class  WeakRef
 
class  PointerHandler
 
class  DeepConstnessPointerHandler
 
class  StrongRefHandler
 
class  StrongCOWRefHandler
 
class  StrongACOWRefHandler
 
class  UniqueRefHandler
 
struct  RawMem
 
class  BaseRef< RawMem< T >, H >
 
class  BlockBase
 
class  BlockBase< T, false >
 
class  BaseIterator
 
class  BaseIterator< COLLECTION, true >
 
struct  CArray
 
class  BlockArray
 
class  BlockArraySelector
 
class  BlockBufferAllocator
 
class  PointerBurstTriePool
 
class  ElementPool
 
class  ArrayBurstTriePool
 
struct  BurstTrieNode
 
struct  BurstTrieBucket
 
struct  BurstTrieBucket< K, UnitType, SIZE >
 
class  BurstTrieMap
 
class  BurstTrieMapSelector
 
class  BurstTrieSet
 
class  ByteOrder
 
class  BytesValue
 
class  Bytes
 
class  Kilobytes
 
class  Kibibytes
 
class  Mebibytes
 
class  Megabytes
 
class  Gibibytes
 
class  Gigabytes
 
class  Terabytes
 
class  Tebibytes
 
class  PrivateGetMapKeyHelper
 
class  PrivateGetMapKey
 
class  GetCollectionKind< COLLECTION, typename SFINAEHelper< void, typename std::decay< COLLECTION >::type::IsCollection >::type >
 
class  BaseCollection
 
class  Collection
 
class  BlockIterator
 
class  ArrayBase0
 
class  ArrayBase
 
class  SetBase0
 
class  SetImpl
 
class  SetBase
 
class  MapBase0
 
class  MapImpl
 
class  MapBase
 
class  ConditionVariableInterface
 
class  Configuration
 
class  ConstData
 
struct  ContainerVariance
 
struct  ContainerVariance< TO, FROM, 0 >
 
class  GenericContainerInterface
 
class  GenericIndexableContainerInterface
 
class  RecursiveContainer
 
class  ContiguousRangeMap
 
class  CpuYieldState
 
class  CpuYield
 
class  CrashHandler
 
struct  CrashCallStackEntry
 
struct  GenericRegisterValue
 
struct  CrashRegisterValue
 
struct  CrashThreadState
 
struct  CrashModuleEntry
 
struct  CrashReportState
 
class  CrashLogKey
 
class  CrashHandlerGlobals
 
struct  CrashReportPropertyItem
 
class  CrashReportProperty
 
class  CrashReportServices
 
class  Crc32C
 
class  CStdLibAllocator
 
class  CustomAllocatorInterface
 
class  CustomSTLAllocator
 
class  DataDescriptionInterface
 
class  SubMenuEntry
 
class  DataDescriptionUIInterface
 
class  DataDescriptionDatabaseInterface
 
class  DataDescriptionDefinitionInterface
 
class  DataDescriptionDefinitionDatabaseInterface
 
class  DataDescriptionDefinitionDatabaseImplInterface
 
class  DataDescriptionObjectInterface
 
class  Array
 
class  DataDictionaryInterface
 
class  DataDictionaryIteratorInterface
 
class  DataDictionaryIterator
 
struct  DataDictionaryKeySet
 
class  DataDictionaryObjectInterface
 
class  DataDictionaryReferenceObjectInterface
 
class  DataFormatReaderInterface
 
class  DataFormatWriterInterface
 
class  DataFormatBaseReaderInterface
 
class  DataFormatBaseWriterInterface
 
class  WriterRef
 
class  WriterRef< Utf32Char >
 
class  ReaderRef
 
class  ReaderRef< Utf32Char >
 
struct  IDENT_VOID
 
class  DESCRIBEFLAGS
 
class  DataSerializeInterface
 
class  DataSerializeWriterInterface
 
class  DataSerializeReaderInterface
 
class  UnregisteredDataTypeErrorInterface
 
struct  IsSimdElementType
 
struct  IsSimdElementType< T, typename SFINAEHelper< void, typename T::VectorStrideType >::type >
 
struct  SimdInfo
 
class  SimdBlock
 
struct  AInt
 
struct  AUInt
 
struct  AFloat
 
struct  CheckedGetDataType
 
class  DataTypeCache
 
class  DataTypeCacheInstance
 
class  DataTypeCacheInstance< T, POLICY, true >
 
class  DataTypeCacheInstance< void, POLICY, true >
 
class  DataTypeCacheInstance< std::nullptr_t, POLICY, true >
 
class  DataTypeCacheInstance< InvalidType, POLICY, true >
 
struct  NamedTupleMembers
 
class  NamedTuple
 
class  TupleValue
 
class  FunctionDataType
 
struct  CheckedGetDataType< T, POLICY, false >
 
struct  DataTypeComponent
 
class  DataTypeBuilderInterface
 
class  DataTypeBuilderEntry
 
struct  DataMemBlock
 
class  Opt
 
class  DataTypePtr
 
class  DataTypeImpl
 
class  DataType
 
class  Data
 
struct  IsZeroInitialized< Data >
 
class  ConstDataPtr
 
class  DataPtr
 
class  MoveDataPtr
 
struct  ForwardingDataPtr
 
class  TrivialDataPtr
 
class  AbstractDataTypeFunctions
 
class  DataTypeReferenceFunctions
 
class  DefaultDataTypeFunctionsBase
 
class  DefaultDataTypeFunctions
 
class  DefaultDataTypeFunctions< T, DATATYPEMODE::SMALLISPOD >
 
class  DefaultDataTypeFunctions< T, DATATYPEMODE::SMALL >
 
class  DefaultDataTypeFunctions< T, DATATYPEMODE::BIG >
 
struct  DefaultDataTypeFunctionsCapabilityFlags
 
class  DataTypeFunctions
 
class  InterfaceDataTypeFunctions
 
struct  NumToString
 
class  InternedId
 
struct  IsTriviallyEquatable< InternedId >
 
struct  IsZeroInitialized< InternedId >
 
class  InternedIdPtr
 
struct  IsTriviallyEquatable< InternedIdPtr >
 
struct  IsZeroInitialized< InternedIdPtr >
 
struct  Member
 
struct  TypeArguments
 
class  DataTypeLib
 
class  TupleDataType
 
class  DelegateDataType
 
class  EnumDataType
 
class  ContainerDataType
 
class  LocalDateTime
 
class  UniversalDateTime
 
class  DebugHardwareBreakPointInterface
 
class  Debugger
 
class  DecoratorInterface
 
class  EagerDecoratorInterface
 
class  WeakDecoratorInterface
 
class  DefaultAllocator
 
struct  IsZeroInitialized< DefaultAllocator >
 
struct  DefaultDefaultValue
 
class  DefaultValueFunctions
 
class  DefaultValueDetector
 
class  DefaultValueZeroInitializedHelper
 
class  DefaultValueZeroInitializedHelper< T &, ALLOW_NONCONST >
 
class  DefaultValueZeroInitializedHelper< const T &, ALLOW_NONCONST >
 
class  DefaultValueTypeHelper
 
class  DefaultValueTypeHelper< T &, ALLOW_NONCONST >
 
class  DefaultValueTypeHelper< const T &, ALLOW_NONCONST >
 
class  DefaultValueFunctionsHelper
 
class  DefaultValueFunctionsHelper< T &, ALLOW_NONCONST >
 
class  DefaultValueFunctionsHelper< const T &, ALLOW_NONCONST >
 
class  DefaultValueFunctions< Result< T > >
 
class  DelegateBase
 
class  Delegate
 
class  Delegate< RESULT(ARGS...)>
 
struct  GenericCastMemberTrait< ParameterPack< TO, TO_REST... >, ParameterPack< FROM, FROM_REST... >, SAFE >
 
struct  GenericCastMemberTrait< Delegate< RESULT_TO(ARGS_TO...)>, Delegate< RESULT_FROM(ARGS_FROM...)>, SAFE >
 
class  DescriptionMessageCallbackInterface
 
class  DescriptionProcessorInterface
 
class  DllInterface
 
struct  FixedSizeArrayWrapperType
 
struct  PrivateFixedSizeArrayBuilder
 
struct  PrivateFixedSizeArrayBuilder< D, std::index_sequence< INDEX... > >
 
class  OutOfMemoryErrorInterface
 
class  FunctionNotImplementedErrorInterface
 
class  IllegalArgumentErrorInterface
 
class  NullptrErrorInterface
 
class  IllegalStateErrorInterface
 
class  UnexpectedErrorInterface
 
class  OperationCancelledErrorInterface
 
class  AggregatedErrorInterface
 
class  AggregatedError
 
class  ErrorIndirectRef
 
class  ErrorPtr
 
class  NoErrorPtr
 
class  UnsupportedArgumentErrorInterface
 
class  UnresolvedErrorInterface
 
class  UnknownErrorInterface
 
class  UnsupportedOperationErrorInterface
 
class  ShutdownErrorInterface
 
class  DisabledErrorInterface
 
class  ErrnoErrorInterface
 
class  FactoryInterface
 
class  FactoryFunctions< Factory< T(ARGS...)>, SUPER >
 
class  FactoryFunctions< Factory< T(const DataDictionary &)>, SUPER >
 
class  Factory< T(ARGS...)>
 
class  FactoryFactory
 
class  FId
 
struct  InternedIdFidBase
 
class  AttributeInternedId
 
class  FId< T, InternedId, HELPER >
 
class  PrivateFIdBase
 
class  PrivateFIdBase< T, const char(&)[N], HELPER >
 
class  RESTRICT
 
class  ValidKeyValuePairTrait
 
class  FileUtilities
 
class  FileFormatInterface
 
class  FileFormatDetectionCacheInterface
 
class  FileFormatHandlerInterface
 
class  FileFormatDetectionInterface
 
struct  FixedBufferMemory
 
struct  FixedBufferMemory< SIZE, PARENT_ALLOCATOR, false >
 
class  FixedBufferAllocatorBase
 
class  FixedBufferAllocator
 
class  FixedSizeBitSet
 
struct  FlexibleArray
 
class  Misc
 
class  SuppressFloatingPointChecks
 
struct  GetIteratorType
 
struct  GetIteratorType< T[N]>
 
class  ReverseIterator
 
class  ForEachIterator
 
class  AutoIterator
 
class  AutoIterator< T[N]>
 
class  NestedForEachIterator
 
class  CommonIteratorTypes
 
class  CommonIteratorTypes< void, I1, I2 >
 
class  ConcatForEachIterator
 
class  ConditionalForEachIterator
 
class  MapForEachIterator
 
class  FilterForEachIterator
 
class  ZipForEachIterator
 
class  IndexForEachIterator
 
class  SingletonForEachIterator
 
class  EraseIterator
 
class  EraseIterator< COLLECTION, SWAP_ERASE, false >
 
class  Iterable
 
class  ForwardRef
 
class  IsObjectReferenceClass< ForwardRef< T > >
 
class  IsObjectReferenceClass< ForwardRef< T > & >
 
class  IsObjectReferenceClass< ForwardRef< T > && >
 
class  IsObjectReferenceClass< const ForwardRef< T > & >
 
class  ForwardRefWithExtraBase
 
class  GenericBaseArray
 
class  GenericDataTemplate
 
class  GetExtraDataCallbackInterface
 
class  HalfFloat
 
class  LIMIT< HalfFloat >
 
struct  IsZeroInitialized< HalfFloat >
 
class  HashBitSet
 
struct  DefaultHashMapEntryHandlerBase
 
struct  HashMapKeyValuePair
 
struct  HashMapValueKeyPair
 
struct  HashMapKeyHashValuePair
 
class  HashMapEntryBase
 
class  HashMapEntryBase< K, V, ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT::HASH_KEY_VALUE >
 
class  HashMapEntryBase< K, V, ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT::KEY_VALUE >
 
class  HashMapEntryBase< K, V, ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT::VALUE >
 
class  HashMapEntryBase< K, V, ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT::KEY_HASH_VALUE >
 
class  HashMapEntryBase< K, V, ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT::HASH_VALUE_KEY >
 
class  HashMapEntryBase< K, UnitType, ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT::HASH_KEY_VALUE >
 
class  HashMapEntryBase< K, UnitType, ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT::KEY_HASH_VALUE >
 
class  HashMapEntryBase< K, UnitType, ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT::HASH_VALUE_KEY >
 
class  HashMapEntryBase< K, UnitType, ENTRY_HANDLER, HASHMAP_ENTRY_LAYOUT::KEY_VALUE >
 
class  HashMap
 
class  HashMapSelector
 
struct  GenericCastMemberTrait< HashMap< K_TO, V_TO >, HashMap< K_FROM, V_FROM >, SAFE >
 
class  HashSet
 
struct  GenericCastMemberTrait< HashSet< TO >, HashSet< FROM >, SAFE >
 
class  HashMapStatistics
 
class  HierarchyIterator
 
struct  DefaultHierarchy
 
class  HierarchyObjectRef
 
struct  DefaultHierarchy< void >
 
class  HierarchyObjectIterator
 
class  HierarchyObjectInterface
 
class  HybridMapGetIteratorHelper
 
class  HybridMap
 
class  HybridMapSelector
 
class  HybridSet
 
class  IndexIteratorDefaultAccess
 
class  IndexIterator
 
class  UInteger
 
class  UInteger< SIZEOF(UIntegerBase) *8 >
 
class  PrivateDummyFree
 
struct  ClassInfoBase
 
struct  GenericCastMemberTrait< TO, FROM, SAFE, typename SFINAEHelper< void, typename TO::DirectlyReferencedType, typename FROM::DirectlyReferencedType >::type >
 
class  IntersectionType
 
class  UnionType
 
struct  IntFloat32
 
struct  IntFloat64
 
class  ReadArchiveInterface
 
class  WriteArchiveInterface
 
class  IoBrowseInterface
 
class  ResolveInterface
 
class  IoConnectionInterface
 
class  IoHandlerInterface
 
class  IoMemoryInterface
 
class  IoDualInOutputStreamInterface
 
class  IoPipeInOutputStreamInterface
 
class  UrlOrStream
 
class  IoErrorInterface
 
class  FileFormatErrorInterface
 
class  UnknownFileSizeErrorInterface
 
class  BaseStreamInterface
 
class  InputStreamInterface
 
class  OutputStreamInterface
 
class  InOutputStreamInterface
 
class  JobInterface
 
class  JobStatusInterface
 
class  JobStatusRef
 
class  JobResultInterface
 
class  JobResultInterface< Result< RESULTVALUETYPE > >
 
class  JobResultInterface< Result< void > >
 
class  JobResultInterface< void >
 
class  JobResultRef
 
class  JobInterfaceTemplate
 
struct  ResultMemJob
 
class  JobRef
 
class  JobResultRef< Result< RESULTVALUETYPE > >
 
class  PromiseRef
 
class  Promise
 
class  JobGroupInterface
 
class  JobGroupRef
 
class  StaticJobArray
 
class  StaticJobGroupInterface
 
class  StaticJobGroupRef
 
class  JobQueueInterface
 
class  ServiceIOJobQueueInterface
 
class  SerialJobQueueInterface
 
class  JobQueueRef
 
class  ServiceIOJobQueueRef
 
class  SerialJobQueueRef
 
class  LazyInit
 
class  LazyInitThreaded
 
struct  LegacyHash
 
class  LexerInterface
 
class  LinearCongruentialRandom
 
class  PseudoRandom
 
struct  LoggerLine
 
class  LoggerTypeInterface
 
class  FileLoggerTypeInterface
 
class  UserLoggerTypeInterface
 
class  LoggerInterface
 
class  MachineInterface
 
class  MachinesInterface
 
class  NonConstMap
 
class  MapInterface
 
class  MapCloneHelper
 
class  MapCloneHelper< MAP & >
 
struct  Col3
 
struct  IsZeroInitialized< Col3< T, 1 > >
 
struct  Col4
 
struct  Vec3
 
struct  IsZeroInitialized< Vec3< T, 1 > >
 
struct  Vec2
 
struct  IsZeroInitialized< Vec2< T, 1, SPACE > >
 
struct  Vec4
 
struct  IsZeroInitialized< Vec4< T, 1 > >
 
struct  SqrMat3
 
struct  Mat3
 
struct  SqrMat2
 
struct  Mat2
 
struct  SqrMat4
 
class  InternedIdInitializer
 
class  ModuleVersionInfoInterface
 
class  MultiIndexBuilder
 
class  MultiIndex
 
class  NullAllocator
 
class  ComponentDescriptor
 
class  IsComplete< Class< T >, COUNTER >
 
class  Class
 
class  ClassInterface
 
class  ObjectInterface
 
class  ErrorInterface
 
class  AdapterRoot
 
class  ComponentHelper
 
struct  PrivateSelfHelperBase
 
struct  PrivateSelfHelper
 
class  ComponentHelper< BASE >
 
class  ComponentHelper< BASE, I, REST... >
 
struct  InterfacesBlock
 
class  ComponentWithBase
 
struct  Undefined
 
class  FunctionBaseInterface
 
class  CombinerInterface
 
class  ObservableBaseInterface
 
class  ObservableNotifyRef
 
class  ObservableNotifyRef< Delegate< RESULT(ARGS...)> >
 
class  ObservableRef
 
class  ObservableStaticInterface
 
class  ObservableImplRef
 
struct  NoOpLock
 
class  SubscriptionSet
 
class  GenericSimpleObservable
 
class  SimpleObservable
 
class  SimpleObservable< RESULT(ARGS...)>
 
class  SimpleObservable< void(ARGS...)>
 
class  ObserverObjectInterface
 
class  StaticObservableStorage
 
class  OpaqueBase
 
class  Opt< T & >
 
class  Opt< const T & >
 
class  Opt< T && >
 
class  ParallelFor
 
class  ParallelImage
 
class  MoveHelper
 
class  MoveHelper< SOURCEITERATOR, DESTITERATOR, CONTENT, true, true >
 
class  MoveHelper< SOURCEITERATOR, DESTITERATOR, CONTENT, true, false >
 
class  MoveHelper< SOURCEITERATOR, DESTITERATOR, CONTENT, false, false >
 
class  MoveHelper< SOURCEITERATOR, DESTITERATOR, CONTENT, false, true >
 
class  MergeSegment
 
class  ParallelSort
 
class  SimpleParallelSort
 
class  ParametricTypeInterface
 
class  ParametricTypeDecorator
 
class  ParserInterface
 
class  MaximalElements
 
class  PointerArray
 
class  ProgressInterface
 
class  Queue
 
class  Range
 
struct  IsZeroInitialized< Range< T > >
 
class  RangeMap
 
class  RangeSet
 
class  RefCountHashMapDefaultHandler
 
class  RefCountHashMap
 
class  SetUsedFrameworks
 
class  SetExpectedModuleDependencies
 
class  Registry
 
class  RegistryDefinition
 
class  RunLoop
 
class  SecureRandom
 
struct  AppendToIndexSequence
 
struct  AppendToIndexSequence< std::index_sequence< SEQ... >, VALUE >
 
struct  SequenceElement
 
struct  SequenceElement< T, 0, VALUE, REST... >
 
struct  IndexSequenceElement
 
struct  IndexSequenceElement< std::index_sequence< VALUES... >, INDEX >
 
struct  GetSequenceElement
 
struct  GetSequenceElement< T, V0 >
 
struct  GetSequenceElement< T, V0, V1 >
 
struct  GetIndexSequenceElement
 
struct  GetIndexSequenceElement< std::index_sequence< VALUES... > >
 
struct  IndexInIndexSequence
 
struct  IndexInIndexSequence< I, std::index_sequence< X, LIST... > >
 
class  Serializer
 
class  NonConstSet
 
class  SetInterface
 
class  SetCloneHelper
 
class  SetCloneHelper< SET & >
 
class  SettingsInterface
 
class  HelperClass
 
class  BaseSort
 
class  SimpleSort
 
class  HelperClass< SORTCLASS, ITERATOR, CONTENT, BASESORTFLAGS::NONE >
 
class  HelperClass< SORTCLASS, ITERATOR, CONTENT, BASESORTFLAGS::MOVEANDCOPYOBJECTS >
 
struct  PerThreadData
 
class  HistogramJob
 
class  ParadisSortJob
 
class  ParadisHealJob
 
class  SortedArray
 
class  DefaultSortedArray
 
struct  Spinlock
 
struct  RWSpinlock
 
class  ScopedLock
 
class  ScopedLockPair
 
class  ScopedReadLock
 
class  ScopedWriteLock
 
class  Matrix4f32
 
class  Matrix4f64
 
class  Matrix4f64SSE
 
class  Vector2f64
 
class  Vector4f32
 
class  Vector4f64
 
class  Vector4i32
 
class  Vector8f32
 
class  Vector8i32
 
class  StackBufferAllocator
 
class  StackTrace
 
class  StreamConversionInterface
 
struct  ConversionTestSet
 
class  ArrayAppendCache
 
class  StringPosition
 
class  StringEnd
 
class  StringCount
 
class  StringTemplate
 
class  SysCharArray
 
class  StringInterface
 
class  CStringInterface
 
class  String
 
class  CString
 
class  ToStringHelper2
 
class  ToStringHelper2< T, false >
 
class  ToStringHelper2< T, true >
 
class  StringProxy
 
class  FormatStatement
 
class  StringConversion
 
class  StringEncodingInterface
 
class  StringDecodingInterface
 
class  LanguageInterface
 
class  Resource
 
class  SymbolificationInterface
 
struct  LockTraits
 
struct  LockTraits< Spinlock >
 
class  SynchronizedValue
 
class  SynchronizedValue< T, Serializer >
 
class  System
 
class  SystemProcessKilledErrorInterface
 
class  SystemProcessOperationErrorInterface
 
class  SystemProcessObjectInterface
 
class  SystemProcessInterface
 
class  SystemErrorInterface
 
class  NSSystemErrorInterface
 
class  TaggedBaseRef
 
class  ThreadInterface
 
class  ThreadResultRef
 
class  ThreadInterfaceTemplate
 
class  ThreadRefTemplate
 
class  ThreadResultRef< Result< RESULTVALUETYPE > >
 
class  ThreadLocalPointer
 
class  ThreadLocalDestructiblePointer
 
class  ThreadSafePtr
 
class  ThreadSafeRef
 
class  JobErrorInterface
 
class  TimerInterface
 
class  AutoTimer
 
class  TimeValue
 
class  Hours
 
class  Minutes
 
class  Seconds
 
class  Milliseconds
 
class  Microseconds
 
class  Nanoseconds
 
struct  IsZeroInitialized< TimeValue >
 
class  TreeMapParent
 
class  TreeMapParent< PARENT, true >
 
class  TreeMap
 
class  Tuple
 
struct  FindUniqueTupleIndex
 
struct  FindUniqueTupleIndex< SEARCHTYPE, Tuple< TYPES... > >
 
class  Tuple<>
 
class  IgnoredPlaceholder
 
struct  TupleElementEquals
 
struct  TupleElementLessThan
 
struct  TupleElementCompare
 
class  UnicodeUtils
 
class  DimensionInterface
 
class  UnitInterface
 
class  UrlInterface
 
class  Url
 
class  UrlFileCacheEntryInterface
 
class  UrlFileCacheInterface
 
class  ResultMemT
 
class  LiteralId
 
class  Id
 
class  LIMIT
 
class  LIMIT< Bool >
 
class  LIMIT< Int64 >
 
class  LIMIT< UInt64 >
 
class  LIMIT< Int32 >
 
class  LIMIT< UInt32 >
 
class  LIMIT< Int16 >
 
class  LIMIT< UInt16 >
 
class  LIMIT< Char >
 
class  LIMIT< UChar >
 
class  LIMIT< Float32 >
 
class  LIMIT< Float64 >
 
struct  Sum
 
struct  Sum< X, Y... >
 
struct  Sum<>
 
struct  Or
 
struct  Or< T, X, Y... >
 
struct  Or< T >
 
struct  TemplateInstantiation
 
struct  SubstituteType
 
struct  SubstituteType< T &, MAP, void >
 
struct  SubstituteType< T *, MAP, void >
 
struct  SubstituteType< const T, MAP, void >
 
struct  SubstituteType< T, MAP, typename SFINAEHelper< void, typename T::Instantiation >::type >
 
class  CompareTemplate
 
class  DefaultCompare
 
class  EqualityCompare
 
class  CStringCompare
 
class  RefCompare
 
class  RefCompare< true, false >
 
class  RefCompare< true, true >
 
class  RenameList
 
struct  IncludeHelper
 
class  FormatTemplateHelper
 
class  FormatTemplateHelper< ARGCNT, const Char(&)[N]>
 
class  DefaultDoc
 
class  DefaultHasher
 
class  FNV1aHasher
 
struct  UniqueHash
 
class  UniqueHasher
 
class  IoFileOutputHelper
 
class  IoFileInputHelper
 
struct  JavaCall
 
struct  JavaMember
 
struct  JavaClass
 
class  JavaClassArray
 
class  JavaClassHash
 
class  JavaHelper
 
class  LockedResourceHelper
 
class  LockedResourceMap
 
class  LRUHashMap
 
class  SourceLocation
 
class  CopyWrapper
 
struct  NumToString< 0 >
 
class  ObserverScopeGuard
 
class  ResultOk< T & >
 
class  ResultOk< void >
 
class  ResultRef
 
struct  ForwardResultPtr
 
class  ResultBase
 
class  ResultBase< T & >
 
class  ResultBase< void >
 
class  PrivateIsErrorClassHelper
 
class  PrivateIsErrorClassHelper< T, true >
 
class  IsErrorClass
 
class  IsErrorClass< ForwardRef< T > >
 
class  ResultSuper
 
class  ResultSuper< RESULT_TYPE, typename SFINAEHelper< void, typename RESULT_TYPE::template ResultFunctions< ResultBase< RESULT_TYPE > > >::type >
 
class  ResultSuper< RESULT_TYPE &, typename SFINAEHelper< void, typename RESULT_TYPE::template ResultFunctions< ResultBase< RESULT_TYPE & > > >::type >
 
struct  RemoveResult
 
struct  RemoveResult< Result< T > >
 
struct  RemoveResult< ResultOk< T > >
 
struct  GenericCastMemberTrait< Result< TO >, Result< FROM >, SAFE >
 
struct  GenericCastTrait< Result< TO >, FROM, SAFE >
 
struct  GenericCastTrait< Result< TO >, Result< FROM >, SAFE >
 
class  ResultIteratorFunctions
 
struct  ReuseData
 
class  ReuseResourceTemplate
 
class  RingBuffer
 
class  StreamConversionHelper
 
class  CollectorThread
 
class  ThreadedUIUpdateBase
 
class  ThreadedUIUpdate
 
class  ThreadedUIUpdateRef
 
class  UuidInterface
 
class  Uuid
 
class  ValueChangedCallbackInterface
 
class  HasValueReceiver
 
class  FirstValueReceiver
 
class  UniqueValueReceiver
 
struct  ViewIteratorMember
 
struct  MemberMap
 
class  WeakRawPtr
 
struct  WeakRefBase
 
struct  WeakRefTargetBase
 
struct  MemoryMetadataProxy
 
class  WeakRefServices
 
class  GUIDHASH
 
class  CryptographyStreamConversionInterface
 
class  CryptoKeyInterface
 
class  CryptoKey
 
class  SSHInterface
 
class  SSLInterface
 
class  GlobalImportInterface
 
class  GlobalUtilsInterface
 
struct  Wires
 
class  GraphModelInterface
 
class  GraphTransaction
 
class  GraphNodeBase
 
class  GraphNodeFunctions
 
class  GraphNodeResultBase
 
class  GraphNode
 
struct  IsZeroInitialized< GraphNode >
 
class  GraphLib
 
class  GraphModelHelper
 
class  GraphAttributeInterface
 
class  GraphMessageInterface
 
class  NodePathInterface
 
class  FastNodePathHash
 
class  AudioObjectInterface
 
struct  DrawDimension
 
struct  IsZeroInitialized< DrawDimension< T > >
 
struct  DrawRect
 
struct  IsZeroInitialized< DrawRect< T > >
 
struct  DrawPoint3d
 
struct  DrawDimension3d
 
struct  DrawVolume
 
struct  ImageHierarchy
 
class  ImageBaseInterface
 
class  ImageTextureInterface
 
class  ImageInterface
 
class  ImageLayerInterface
 
class  ImageFunctionsInterface
 
class  BITS
 
class  ColorProfileInterface
 
class  ColorProfileConvertInterface
 
class  ColorSpaceInterface
 
class  ExifInterface
 
class  ExifStaticInterface
 
class  ColorProfileLegacyProcessorInterface
 
class  ImageChannelTypeInterface
 
class  ImageChannelInterface
 
struct  BlendPixelHandlerStruct
 
class  ImagePixelBlendInterface
 
struct  IsZeroInitialized< PixelFormatGroup >
 
struct  PixelConstBuffer
 
struct  PixelMutableBuffer
 
struct  ImageBufferTemplate
 
struct  ConvertFuncChannelHelper
 
class  PixelFormatInterface
 
class  PixelFormatsInterface
 
class  PixelFormatDynamicInterface
 
class  PixelFormatGroupInterface
 
class  PixelFormatIterator
 
class  PixelFormatIndexedColorInterface
 
struct  PixelDepthInfo
 
struct  PixelDepthInfo< Pix8u >
 
struct  PixelDepthInfo< Pix8s >
 
struct  PixelDepthInfo< Pix16u >
 
struct  PixelDepthInfo< Pix16s >
 
struct  PixelDepthInfo< Pix32u >
 
struct  PixelDepthInfo< Pix32s >
 
struct  PixelDepthInfo< Pix16f >
 
struct  PixelDepthInfo< Pix32f >
 
struct  PixelDepthInfo< Pix64f >
 
struct  ChannelOffsetHelper
 
class  PixelFormatTemplateBase
 
struct  ImagePos
 
struct  GetPixelHandlerStruct
 
struct  SetPixelHandlerStruct
 
class  ImagePixelStorageInterface
 
struct  DeepImagePixelConstBuffer
 
struct  DeepImagePixelMutableBuffer
 
class  ImagePixelDeepImageStorageInterface
 
class  UpdateRegionObserver
 
class  VectorImageInterface
 
class  ImageRegionObserverInterface
 
class  ImageRegionObservableInterface
 
class  ImageRegionObservableHandlerInterface
 
class  ImageRegionTilesObserverInterface
 
class  ImageRegionObserverStorage
 
class  ImageUrlCacheInterface
 
struct  LayerSetCompare
 
class  LayerSetInterface
 
class  MediaStreamAudioDataExportInterface
 
class  MediaBaseInterface
 
class  MediaConverterInterface
 
class  MediaConverterErrorInterface
 
class  MediaSessionWrongTypeErrorInterface
 
class  MediaStreamEOFErrorInterface
 
class  MediaSessionFileFormatHandlerInterface
 
class  MediaInputInterface
 
class  MediaOutputInterface
 
class  MediaOutputTextureInterface
 
class  MediaOutputUrlInterface
 
class  MediaSessionInterface
 
class  MediaStreamInterface
 
class  MediaStreamExifDataInterface
 
class  MediaStreamImageBaseInterface
 
class  MediaStreamImageDataImportInterface
 
class  MediaStreamImageDataExportInterface
 
class  MediaStreamImageDataForwardImportInterface
 
class  MediaStreamAudioDataImportInterface
 
class  MediaStreamFormatInterface
 
class  MediaStreamPropertiesInterface
 
class  LIMIT< Vector2d32 >
 
class  LIMIT< Vector2d64 >
 
class  LIMIT< Vector4d32 >
 
class  LIMIT< Vector4d64 >
 
class  LIMIT< Vector32 >
 
class  LIMIT< Vector64 >
 
class  LIMIT< Matrix32 >
 
class  LIMIT< Matrix64 >
 
class  LIMIT< Color32 >
 
class  LIMIT< Color64 >
 
class  LIMIT< ColorA32 >
 
class  LIMIT< ColorA64 >
 
class  BigIntegerInterface
 
class  BigInteger
 
class  BlendTweenInterface
 
class  BlendAnimationInterface
 
class  BlendFunctionInterface
 
class  Complex
 
class  FFTInterface
 
class  Fraction
 
class  DefaultReification
 
class  Dispatch1
 
class  Dispatch1< ALGORITHM, std::tuple< TYPES... >, REIFICATION >
 
class  Dispatch2
 
class  Dispatch2< ALGORITHM, std::tuple< TYPES... >, REIFICATION >
 
struct  GradientKnot
 
class  GradientInterface
 
class  GradientRenderDataInterface
 
struct  IndexedGradientKnot
 
class  SortedGradientKnots
 
class  IndexedGradientSampler
 
class  GradientSampler
 
class  PerformanceBaseArray
 
struct  KDTreeNode
 
struct  KDTreeNearest
 
struct  KDStackArray
 
class  KDTree
 
class  MatrixNxM
 
class  MatrixNxMInterface
 
class  ConstMatrixNxMInterface
 
struct  PRSMatrixData
 
class  NoiseInterface
 
class  RenderNoiseInterface
 
class  NURBSTests
 
class  NURBSCurveWithContinuity
 
class  NURBSCurveInterface
 
struct  KnotInfo
 
class  NURBSCurve
 
class  PolynomSolver
 
class  Quaternion
 
struct  MathFuncHelper
 
struct  MathFuncHelper< Vec2< T >, FUNC >
 
struct  MathFuncHelper< Vec3< T >, FUNC >
 
struct  MathFuncHelper< Vec4< T >, FUNC >
 
struct  MathFuncHelper< Col3< T >, FUNC >
 
struct  MathFuncHelper< Col4< T >, FUNC >
 
struct  SplineMapperKnot
 
class  SplineMapperInterface
 
struct  PrimitiveInformation
 
struct  MeshDistanceData
 
struct  SplineDistanceData
 
class  DistanceQueryInterface
 
class  CustomDataTagDisplayInterface
 
class  MeshAttributeClassInterface
 
class  CustomDataTagClassInterface
 
class  MeshAttribute
 
class  PolyData
 
class  PolygroupInformation
 
class  VoxelizationInterface
 
class  ChangeListInterface
 
class  FileMonitorItemInterface
 
class  FileMonitor
 
class  FormulaParseErrorInterface
 
class  FormulaExecutionErrorInterface
 
class  FormulaNumberErrorInterface
 
class  FormulaParserCacheInterface
 
class  FormulaParserInterface
 
struct  GmlNode
 
struct  GmlTarget
 
struct  GmlNodeAttribs
 
class  GmlGraphInterface
 
class  GmlWriterInterface
 
class  IoDocument
 
class  IoXmlNodeInterface
 
class  IoXmlParser
 
class  ProfilerConstant
 
class  Profiler
 
class  ProfileManagerInterface
 
class  ProfilingPoint
 
struct  ProfilingPointHelper
 
class  ProgressMonitorInterface
 
class  RamDiskInterface
 
class  ReferenceWrapper
 
class  RuleParserInterface
 
class  ParseHelper
 
class  SourceControlChangeEntry
 
class  SourceControlInterface
 
class  SqlDatabaseInterface
 
class  RegularExpressionInterface
 
class  SubDataInterface
 
class  SubDataOperationInterface
 
class  UnitTestErrorInterface
 
class  UnitTestInterface
 
class  UnitTestComponent
 
class  UpdateJobEvent
 
struct  CellEdge
 
class  CellData
 
class  ConvexDecompositionInterface
 
struct  ConvEdge
 
struct  ConvexHullData
 
class  ConvexHullInterface
 
class  Delaunay3DInterface
 
class  ExactPredicates2DInterface
 
class  TopologyContainer
 
class  PolygonToTessellationMap
 
class  GenericPolygon
 
class  EdgePairTemplate
 
struct  SelectionWrapper
 
class  GeomConstants
 
class  DegeneratedInputErrorInterface
 
class  GeometryUtilsInterface
 
class  GenericInterpolate
 
class  InterpolateTypeInterface
 
class  Poly
 
class  SimpleMeshObject
 
struct  Tetrahedron
 
class  Voronoi3DInterface
 
class  ConditionVariableDependency
 
class  HttpCodeErrorInterface
 
class  AioStatusInterface
 
class  AioReaderInterface
 
class  AioWriterInterface
 
class  AioServiceInterface
 
class  NetworkErrorInterface
 
class  NetworkTimeoutErrorInterface
 
struct  NetworkIpAddressStruct
 
class  NetworkAdapterInterface
 
class  NetworkConnectionInterface
 
class  NetworkIpInterface
 
struct  NetworkSockAddrIn
 
class  NetworkIpAddrInterface
 
class  NetworkIpAddrPortInterface
 
class  NetworkIpAddr
 
class  NetworkIpAddrPort
 
class  SSHNetworkConnectionInterface
 
class  SSLNetworkConnectionInterface
 
class  NetworkTcpSocketInterface
 
class  NetworkTcpConnectionInterface
 
class  NetworkTcpServerInterface
 
struct  NetworkTcpConnectionOptions
 
class  NetworkTcpInterface
 
class  NetworkUdpSocketInterface
 
class  NetworkUdpBoundSocketInterface
 
class  NetworkUdpChannelInterface
 
class  NetworkUdpSenderInterface
 
class  NetworkUdpServerInterface
 
struct  NetworkUdpChannelOptions
 
struct  NetworkUdpSenderOptions
 
struct  NetworkUdpServerOptions
 
class  NetworkUdpInterface
 
class  UrlRedirectInterface
 
class  NetworkOAuthSessionInterface
 
class  NetworkProxyInterface
 
struct  ServiceDiscovery
 
struct  ResourceIdentifier
 
struct  ServiceProviderDetails
 
class  ServiceAnnouncementRequestInterface
 
class  ServiceSubscriptionRequestInterface
 
class  ServiceAnnouncementInterface
 
class  ServiceSubscriptionInterface
 
class  ServiceBusInterface
 
class  SmtpErrorInterface
 
struct  SmtpReceiver
 
class  SmtpMailInterface
 
class  NetworkWebServerInterface
 
class  NetworkIpHandlerInterface
 
class  NetworkHttpHandlerInterface
 
class  NetworkWebSocketConnectionInterface
 
class  NetworkWebSocketSignalInterface
 
class  NetworkWebSocketClientConnectionInterface
 
class  NetworkWebSocketServerInterface
 
class  NetworkZeroConfBrowserInterface
 
class  NetworkZeroConfServiceInterface
 
class  NetworkZeroConfInterface
 
class  NodeContextAssetInterface
 
class  FixedSizeArray
 
struct  DefaultValueFunctions< nodes::TemplateArguments >
 
class  NimbusBaseInterface
 
struct  ErrorStorage
 
class  PyModuleInterface
 
struct  ResultOffsetHelper
 
class  LocalStringStorage
 
struct  Runtime
 
struct  LoadRuntime
 
class  LibraryInterface
 
struct  DocStringMeta
 
class  VmDebuggerConnectionInterface
 
class  VirtualMachineScopeInterface
 
class  VirtualMachineInterface
 
class  FilterInterface
 
class  FilterCommandQueueInterface
 
class  FilterContextInterface
 
class  FilterImageInterface
 
class  ObserveMeInterface
 
struct  FunctionSettings
 
struct  CommandSettings
 
struct  ClassicCommandSettings
 
struct  MenuEntry
 
struct  StatisticsElement
 
class  SDKDatabaseInterface
 
class  ExecuteTestsInterface
 
class  PluginToolsInterface
 
class  PythonToolsInterface
 
struct  SnippetSettings
 
class  SourceToolsInterface
 
class  TestToolsInterface
 
struct  DoxTitle
 
struct  DoxSnippet
 
struct  DoxPage
 
struct  CodeSnippet
 
struct  Issue
 
class  TextToolsInterface
 
class  CoreFoundationCreatedPointerHandler
 
class  CFStrongRef
 
class  NSCreatedPointerHandler
 
class  NSStrongRef
 
struct  NSStrongId
 
class  SystemWindows
 
class  VolumeInterface
 
class  GridAccessorRef
 
class  GridAccessorInterface
 
class  GridAccessorCreationInterface
 
class  GridAccessorRef< Generic >
 
struct  VolumeCommandData
 
class  GridIteratorRef
 
class  GridIteratorInterface
 
class  GridIteratorCreationInterface
 
struct  VolumeRay
 
struct  VolumeRayHit
 
class  VolumeRayIntersectorRef
 
class  VolumeRayIntersectorInterface
 
class  VolumeRayIntersectorCreationInterface
 
class  VolumeRayIntersectorRef< Generic >
 
struct  SDFFilterSettings
 
struct  FilterSettings
 
struct  FieldSampleData
 
struct  VolumeConversionPolygon
 
class  VolumeToolsInterface
 
class  PointsToVolumeListInterface
 

Typedefs

using BuildBrowserEntryDelegate = Delegate< Result< Data >(const AssetBrowserRef &assetBrowser, BUILDBROWSERENTRYCOMMAND cmd, const Data &data, const Data &parent, const BuildBrowserEntryData &add)>
 
using AssetTypeNameMapKey = Tuple< AssetRepositoryRef, Id, Id, Id, Bool >
 
using AssetTypeNameMap = HashMap< AssetTypeNameMapKey, Tuple< String, String > >
 
using InsertPointType = Tuple< Id, Vector, Vector2d, ColorA >
 
using AssetRenaming = Delegate< Result< Id >(const Id &prevId)>
 
using AssetUtilities = AssetUtilitiesInterface
 
using OutputStreamDecoratorFactory = Delegate< Result< OutputStreamRef >(const OutputStreamRef &stream)>
 
using AssetRepositoryUpdate = Tuple< AssetDescription, BaseArray< AssetBase > >
 
using BuiltinAssetReceiver = Delegate< Result< Bool >(const Asset &asset, const DataDictionary &meta, const Url &metaUrl)>
 
using BuiltinAssetLoaderNew = Delegate< Result< Bool >(const Block< const Id > &types, const Id &aid, ASSET_FIND_MODE findMode, const BuiltinAssetReceiver &receiver)>
 
using BuiltinAssetLoader = Delegate< Result< Bool >(const Block< const Id > &types, const Id &aid, ASSET_FIND_MODE findMode, const ValueReceiver< const Asset &, const DataDictionary & > &receiver)>
 
using DndAsset = Tuple< AssetDescription, Url, String >
 
using AddAssetMetaData = HashMap< InternedId, Tuple< Data, AssetMetaDataInterface::KIND > >
 
using PresetStorage = DataDictionary
 
using DataDescriptionEntry = DataDictionary
 
using LanguageStringDataDescriptionDefinition = HashMap< Id, DataDescriptionDefinition > MAXON_FORWARD("maxon/datadescriptiondefinition.h")
 
using LanguageDictionary = DataDictionary
 
using C4DBaseDocumentType = ClassicObjectWrapper< ::BaseDocument >
 
using C4DBaseObjectType = ClassicObjectWrapper< ::BaseObject >
 
using NimbusForwardRef = ForwardRefWithExtraBase< NimbusRef, NimbusBaseRef >
 
using CustomLicenseItemDelegate = Delegate< Result< void >(const InternedId &featureId, const String &provider, Bool isValid, const CString &jwtString)>
 
using NodeMaterialLinkResolveFunc = Delegate< Result< ::BaseList2D * >(::BaseLink *link, ::BaseDocument *baseDocument)>
 
using DescCompareEntry = Tuple< Bool, BaseContainer, DescID, maxon::String >
 
using CommandGetStateDelegate = Delegate< Int32(::BaseDocument *)>
 
using CreateMaterialWithDataDelegate = Delegate<::BaseMaterial *(::BaseDocument *, const Data &textureUrlOrColor)>
 
using CreateDefaultMaterialDelegate = Delegate<::BaseMaterial *(::BaseDocument *)>
 
using DescTranslationRef = StrongCOWRef< DescTranslation >
 
using PyBaseElementFactoryType = Factory< PythonElementBaseRef(BaseList2D *bl)>
 
using PyEmbeddedElementFactoryType = Factory< PythonElementEmbeddedRef(BaseList2D *bl, const DescID &parameter)>
 
using PyDirectoryElementFactoryType = Factory< PythonElementBaseRef(Url dir)>
 
using PyScriptElementFactoryType = Factory< PythonElementScriptRef(BaseList2D *bl)>
 
using GetExtraDataCallbackType = Delegate< DelegateBase(const Id &)>
 
using PatchC4DDescriptionEntryDelegate = Delegate< Result< void >(BaseContainer &param)>
 
using CommandCacheMap = HashMap< Id, CommandCacheRef >
 
using CommandCacheDataRef = StrongRef< CommandCacheData >
 
template<typename T >
using ABIReturnType = ABIParamType< T >
 
using IndexPair = Pair< Int, Int >
 
using Int16 = int16_t
 
using UInt16 = uint16_t
 
using Int32 = int32_t
 
using UInt32 = uint32_t
 
using Int64 = int64_t
 
using UInt64 = uint64_t
 
using Bool = bool
 
using Float32 = float
 
using Float64 = double
 
using Char = char
 
using UChar = unsigned char
 
using Int = Int64
 
using UInt = UInt64
 
using Float = Float64
 
using Byte = std::byte
 
using Utf32Char = char32_t
 
using Utf16Char = char16_t
 
using SysChar = char
 
using HashInt = UInt
 
using OverloadRank0 = PrivateOverloadRank0 *
 
using OverloadRank1 = PrivateOverloadRank1 *
 
using OverloadRank2 = PrivateOverloadRank2 *
 
using OverloadRank3 = PrivateOverloadRank3 *
 
using OverloadRank4 = PrivateOverloadRank4 *
 
using OverloadRank5 = PrivateOverloadRank5 *
 
using OverloadRankMax = OverloadRank5
 
template<typename T , Int N>
using AddArrayT = T[N]
 
template<typename T >
using AddArrayOfUnknownBoundT = T[]
 
template<typename TO , typename FROM , Bool SAFE>
using GenericCastReturnType = std::enable_if< GenericCastTrait< TO, typename maxon::details::MakeLValueConst< FROM >::type, SAFE >::value, typename GenericCastTrait< TO, typename maxon::details::MakeLValueConst< FROM >::type, SAFE >::ReturnType >
 
using InitMTable = void(*)()
 
using DestructorPointer = void(*)(const void *)
 
using BoolLValue = DefaultLValue< Bool >
 
template<typename T >
using WritableArrayInterface = const NonConstArray< T >
 
using AtomicInt32 = Atomic32< Int32 >
 
using AtomicUInt32 = Atomic32< UInt32 >
 
using AtomicInt64 = Atomic64< Int64 >
 
using AtomicUInt64 = Atomic64< UInt64 >
 
using AtomicInt = Atomic64< Int >
 
using AtomicUInt = Atomic64< UInt >
 
using AtomicInt16 = Atomic16< Int16 >
 
using AtomicUInt16 = Atomic16< UInt16 >
 
using AtomicInt8 = Atomic8< Char >
 
using AtomicUInt8 = Atomic8< UChar >
 
using AtomicFloat32 = AtomicFloatType< Float32 >
 
using AtomicFloat64 = AtomicFloatType< Float64 >
 
using AtomicVoidPtr = AtomicPtr< void >
 
using BackgroundEntryTuple = Tuple< WeakRef< BackgroundProgressRef >, Int >
 
template<typename T , Int COUNT, Int MINCHUNKSIZE = COUNT, BASEARRAYFLAGS MEMFLAGS = BASEARRAYFLAGS::NONE, typename ALLOCATOR = DefaultAllocator>
using BufferedBaseArray = typename BufferedBaseArraySelector< COUNT, MINCHUNKSIZE, MEMFLAGS, ALLOCATOR >::template Type< T >
 
using BitSet = BaseBitSet< DefaultAllocator, UInt >
 
template<typename T >
using Pointer = BaseRef< T, PointerHandler >
 
template<typename T >
using UniqueRef = BaseRef< T, UniqueRefHandler >
 
template<typename T >
using StrongRef = BaseRef< T, StrongRefHandler >
 
template<typename T >
using StrongCOWRef = BaseRef< const T, StrongCOWRefHandler >
 
template<typename T >
using AutoMem = UniqueRef< RawMem< T > >
 
template<typename T >
using StridedBlock = Block< T, true >
 
template<typename T , Bool STRIDED = false>
using MoveBlock = Block< T, STRIDED, true >
 
using PersistentIdBuffer = BufferedBaseArray< Int64, 10 >
 
using CrashReportPropertyArray = BlockArray< CrashReportPropertyItem, 8 >
 
using DataDescriptionWithUIAndString = Tuple< DataDescription, DataDescription, DataDescription >
 
using LanguageStringDataDescription = HashMap< Id, DataDescription >
 
using DataDescriptionWithUIAndLanguageStrings = Tuple< DataDescription, DataDescription, LanguageStringDataDescription >
 
using VariadicIdsElement = Tuple< Int, Id, String, HashMap< Id, Int > >
 
using VariadicIdsType = Array< VariadicIdsElement >
 
using ContextVarTuple = Tuple< DataDictionary, GetDataCallbackType >
 
using ContextVarsMap = HashMap< Id, ContextVarTuple >
 
using GetDescEntriesCallbackType = Delegate< Result< Tuple< InternedId, DataDictionary, DataDictionary > >(const InternedId &id, GETDATAFLAGS flags)>
 
using ConditionToken = Tuple< const CString &, const CString &, CONDITIONTOKENTYPE >
 
using ProcessEnumListDelegate = Delegate< Result< void >(const Id &epId, const DataDictionary &guiEntry, const AssetRepositoryRef &repository, const Data *filterData, const ValueReceiver< Tuple< Id, Data, String > && > &addValue)>
 
using EnumVariableResolveDelegate = Delegate< Result< CString >(const CString &variable, const CString &fullString, const AssetRepositoryRef &repository, const GetDataCallbackType &getDataCallback, Opt< const DataDictionary & > dataEntry, Opt< const DataDictionary & > guiEntry)>
 
using GetDataCallbackType = Delegate< Result< Data >(const InternedId &id, const DataDictionary &dataEntry, GETDATAFLAGS flags)>
 
using DataDescriptionDefinitionWithUIAndLanguageStrings = Tuple< DataDescriptionDefinition, DataDescriptionDefinition, LanguageStringDataDescriptionDefinition >
 
using BuildSubMenuValueReceiver = ValueReceiver< SubMenuEntry && >
 
using DescriptionMessageCheck = Delegate< Result< DESCRIPTIONMESSAGECHECKFLAGS >(const DataDictionary &userData)>
 
using DescriptionMessageBuildSubMenu = Delegate< Result< void >(const DataDictionary &userData, const BuildSubMenuValueReceiver &menuEntries)>
 
using DescriptionMessageCall = Delegate< Result< void >(const DataDictionary &userData, DataDictionary &multiSelectionStorage)>
 
using DescriptionMessageFunction = Tuple< Id, DescriptionMessageCheck, DescriptionMessageBuildSubMenu, DescriptionMessageCall >
 
using DataFormatReaderFactory = Factory< DataFormatReaderRef(UrlOrInputStream &&)>
 
using DataFormatWriterFactory = Factory< DataFormatWriterRef(UrlOrOutputStream &&)>
 
using KeyValueConversionFunc = void(void *, Char *)
 
using CreateIoHelperFunc = ResultPtr< void >()
 
using DeleteIoHelperFunc = void(void *)
 
using ReadIoHelperFunc = Result< void >(DataSerializeInterface *, void *, void *, UInt)
 
using WriteIoHelperFunc = Result< void >(DataSerializeInterface *, void *, void *, UInt)
 
using WidthConversionFunc = Bool(void *source, void *dest)
 
using ReferenceSubstitutionFunction = Delegate< Result< const ObjectInterface * >(const ObjectInterface *input)>
 
using StreamSubstitutionFunction = Delegate< Result< ObjectRef >(ObjectRef input, const Id &compressorId)>
 
using GetChildrenTypesCallback = Delegate< Result< Tuple< String, Bool > >(const Member &elementType, const ParametricTypeInterface *parametricType)>
 
using GetDataTypeNameDelegate = Delegate< Result< Tuple< String, String > >(DATATYPEBUILDERNAME category, const DataType &dt, const GetChildrenTypesCallback &getChildrenTypes, const ParametricTypeInterface *parentTypeId, const ParametricTypeInterface **skipParentType)>
 
using GetChildrenCountDelegate = Delegate< Tuple< Int, Int, Bool >()>
 
using InstantiateDataTypeDelegate = Delegate< Result< DataType >(const BaseArray< Member > &members)>
 
using GetParentTypeSupportDelegate = Delegate< Block< ParametricType >()>
 
using GetFolderDelegate = Delegate< Block< const Id >()>
 
using RemoteDateTime = LocalDateTime
 
template<typename I >
using ObjectBaseRef = typename maxon::details::ObjectBaseRefImpl< I::REFERENCE_KIND >::type
 
template<typename... T>
using ValueReceiver = Delegate< Result< Bool >(T...)>
 
using QueryStartupOrder = void(*)(BaseArray< Url > &dllsToLoad)
 
template<typename EXECUTION >
using ExecutionInterface = JobInterfaceTemplate< EXECUTION >
 
template<typename FACTORY >
using FactoryBase = RefBase< FactoryFunctions< FACTORY, FactoryInterface::ReferenceFunctions< RefBaseFn< DirectRef< const FactoryInterface, StrongRefHandler, FACTORY > >> >>
 
using Group = void
 
using GenericData = GenericDataTemplate< false >
 
using GenericDataRef = GenericDataTemplate< true >
 
using IdAndVersion = Tuple< Id, Id >
 
using UIntegerBase = UInt32
 
using NativeUInteger = UInteger< SIZEOF(Int) *8 >
 
template<typename T , Bool HAS_ERROR>
using AddResult = typename maxon::details::AddResultHelper< T, HAS_ERROR >::type
 
using ExtractCallback = Delegate< Result< Bool >(const String &inputName, Url &outputName, IOATTRIBUTES &fileAttributes)>
 
using IoProgressDelegate = Delegate< Result< void >(Int64 alreadyRead, Int64 totalBytes)>
 
using PIPEHANDLE = int
 
using UrlOrInputStream = UrlOrStream< InputStreamRef >
 
using UrlOrOutputStream = UrlOrStream< OutputStreamRef >
 
template<typename RESULTVALUETYPE >
using FutureRef = JobResultRef< RESULTVALUETYPE >
 
using TransformColorDelegate32 = Delegate< Color32(const Color32 &)>
 
using TransformColorDelegate64 = Delegate< Color64(const Color64 &)>
 
using TransformValueDelegate32 = Delegate< Float32(const Float32 &)>
 
using TransformValueDelegate64 = Delegate< Float64(const Float64 &)>
 
using TransformColorDelegate = TransformColorDelegate64
 
using TransformValueDelegate = TransformValueDelegate64
 
using CreateNewMachineCallback = Delegate< Result< MachineRef >(const String &machineUuid)>
 
using CheckExistingMachineCallback = Delegate< Result< void >(const MachineRef &machineRef)>
 
using CreateObjectRefFunc = ObjectRef(*)()
 
template<typename K , typename V >
using WritableMapInterface = const NonConstMap< K, V >
 
using SquareMatrix32 = SqrMat3< Vector32 >
 
using SquareMatrix64 = SqrMat3< Vector64 >
 
using SquareMatrix = SqrMat3< Vector >
 
using Matrix32 = Mat3< Vector32 >
 
using Matrix64 = Mat3< Vector64 >
 
using Matrix = Mat3< Vector >
 
using SquareMatrix2d32 = SqrMat2< Vector2d32 >
 
using SquareMatrix2d64 = SqrMat2< Vector2d64 >
 
using SquareMatrix2d = SqrMat2< Vector2d >
 
using Matrix2d32 = Mat2< Vector2d32 >
 
using Matrix2d64 = Mat2< Vector2d64 >
 
using Matrix2d = Mat2< Vector2d >
 
using SquareMatrix4d32 = SqrMat4< Vector4d32 >
 
using SquareMatrix4d64 = SqrMat4< Vector4d64 >
 
using SquareMatrix4d = SqrMat4< Vector4d >
 
using MultiIndex64 = MultiIndex< UInt64 >
 
template<typename TO , typename FROM >
using Out = std::is_constructible< TO, FROM >
 
using ClassTransformer = Delegate< Result< void >(ClassInterface *)>
 
template<typename C , typename... INTERFACES>
using Component = ComponentWithBase< C, ComponentRoot, INTERFACES... >
 
template<typename FROM , typename C , typename... INTERFACES>
using AdapterComponent = ComponentWithBase< C, AdapterRoot, FROM, INTERFACES... >
 
template<typename... INTERFACES>
using SelfPtr = typename ComponentHelper< ComponentRoot, INTERFACES... >::type::SelfPtr
 
using ObservableForwardFunction = Result< Data >(*)(const DelegateBase &observerFunction, const Block< const ConstDataPtr > &data)
 
using FunctionBaseWeakRef = WeakRef< FunctionBaseRef >
 
using OpaqueRef = StrongRef< OpaqueBase >
 
template<typename T >
using Optional = Opt< T >
 
template<typename T , typename ARRAY = BaseArraySelector<>, typename COMPARE = DefaultCompare, Bool KEEP_DUPLICATES = false>
using MinimalElements = MaximalElements< T, ARRAY, COMPARE, KEEP_DUPLICATES, true >
 
using JobCancelDelegate = Delegate< Result< void >(const ProgressRef &progressRef)>
 
using Frame = Range< Vector2d >
 
using IntFrame = Range< IntVector2d >
 
using SecureRandomProvider = Pointer< _SecureRandomProvider >
 
template<Bool ZERO_BASED, size_t... VALUES>
using PartialSumSequence = typename maxon::details::PartialSumSequenceHelper< ZERO_BASED, std::index_sequence<>, 0, VALUES... >::type
 
template<typename T >
using WritableSetInterface = const NonConstSet< T >
 
using StreamConversionFactory = Factory< StreamConversionRef(const DataDictionary &)>
 
using Utf16CharBuffer = BufferedBaseArray< Utf16Char, 512 >
 
using Utf32CharBuffer = BufferedBaseArray< Utf32Char, 256 >
 
using FROMSTR = void(*)(void *p, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
template<typename T >
using Synchronized = SynchronizedValue< T, Spinlock >
 
template<typename T >
using RWSynchronized = SynchronizedValue< T, ARWLock >
 
using ExecuteProgramCallback = Int32(*)(SystemProcessObjectRef processRef, EXECUTEPROGRAMCALLBACK cmd, void *userdata, const Url &logfile)
 
using ThreadRef = ThreadRefTemplate< ThreadInterface >
 
template<typename T1 , typename T2 >
using Pair = typename maxon::details::PairSelector< T1, T2 >::type
 
template<Int N, typename T >
using HomogenousTupleType = typename maxon::details::HomogenousTupleTypeHelper< N, T >::type
 
using UnitsArray = StrongCOWRef< BaseArray< Unit > >
 
using UrlScheme = Id
 
using UrlIoShowInOSDelegate = Delegate< Result< Bool >(const Url &url, IOSHOWINOSFLAGS flags)>
 
using ResultMem = ResultMemT< Bool >
 
template<typename... BASES>
using NonEmptyBases = typename maxon::details::NonEmptyBasesHelper< typename std::conditional< STD_IS_REPLACEMENT(empty, BASES), EmptyClass, BASES >::type... >::type
 
using TOSTR = void(*)(String &result, const void *ptr, const FormatStatement *formatStatement)
 
template<typename T >
using ResultPtr = ResultMemT< T * >
 
using ThreadedUIUpdateBaseRef = StrongRef< ThreadedUIUpdateBase >
 
template<typename T , Bool ERROR_WHEN_AMBIGUOUS = true>
using SingleValueReceiver = UniqueValueReceiver< T, ERROR_WHEN_AMBIGUOUS >
 
using Vector32 = Vec3< Float32, 1 >
 
using Vector64 = Vec3< Float64, 1 >
 
using Vector = Vec3< Float, 1 >
 
using IntVector32 = Vec3< Int32, 1 >
 
using UIntVector32 = Vec3< UInt32, 1 >
 
using IntVector64 = Vec3< Int64, 1 >
 
using IntVector = Vec3< Int, 1 >
 
using Color32 = Col3< Float32, 1 >
 
using Color64 = Col3< Float64, 1 >
 
using Color = Col3< Float, 1 >
 
using GenericVector = Vec3< GenericArithmetic, 1 >
 
using Vector2d32 = Vec2< Float32, 1 >
 
using Vector2d64 = Vec2< Float64, 1 >
 
using Vector2d = Vec2< Float, 1 >
 
using IntVector2d32 = Vec2< Int32, 1 >
 
using UIntVector2d32 = Vec2< UInt32, 1 >
 
using IntVector2d64 = Vec2< Int64, 1 >
 
using UIntVector2d64 = Vec2< UInt64, 1 >
 
using IntVector2d = Vec2< Int, 1 >
 
using GenericVector2d = Vec2< GenericArithmetic, 1 >
 
using Vector4d32 = Vec4< Float32, 1 >
 
using Vector4d64 = Vec4< Float64, 1 >
 
using Vector4d = Vec4< Float, 1 >
 
using IntVector4d32 = Vec4< Int32, 1 >
 
using IntVector4d64 = Vec4< Int64, 1 >
 
using IntVector4d = Vec4< Int, 1 >
 
using ColorA32 = Col4< Float32, 1 >
 
using ColorA64 = Col4< Float64, 1 >
 
using ColorA = Col4< Float, 1 >
 
using GenericVector4d = Vec4< GenericArithmetic, 1 >
 
using MemoryObserverCallback = MEMORY_OBSERVER_FLAGS(*)(void *callbackData, const void *target, MEMORY_OBSERVER_STATE state)
 
using MemoryMetadataDestructor = void(*)(void *metadata)
 
using BLOCK_CIPHER_CTR_CALLBACK = Delegate< void(Int block, Int blockSize, UChar *nonce)>
 
using LIBSSH2_PASSWD_CHANGEREQ_FUNC = void(*)(LIBSSH2_SESSION *session, char **newpw, int *newpw_len, void **abstract)
 
typedef int(* sslctxsetverifycallback) (int, X509_STORE_CTX *)
 
using TimeStamp = UInt64
 
using GraphConnection = Tuple< GraphNode, Wires >
 
using NodeConnection = Tuple< NodePath, NodePath >
 
using IoNodePath = Tuple< NodePath, InternedId >
 
using IoNodeConnection = Tuple< IoNodePath, IoNodePath >
 
using IoGraphNode = Tuple< GraphNode, InternedId >
 
using GraphAttributeMap = HashMap< InternedId, ConstDataPtr >
 
using PathBlock = Block< const InternedId >
 
using DrawDimensionInt = DrawDimension< Int >
 
using DrawDimensionFloat = DrawDimension< Float >
 
using DrawRectInt = DrawRect< Int >
 
using DrawRectFloat = DrawRect< Float >
 
using DrawPoint3dInt = DrawPoint3d< Int >
 
using DrawPoint3dFloat = DrawPoint3d< Float >
 
using DrawDimension3dInt = DrawDimension3d< Int >
 
using DrawDimension3dFloat = DrawDimension3d< Float >
 
using DrawVolumeInt = DrawVolume< Int >
 
using DrawVolumeFloat = DrawVolume< Float >
 
using Pix = UChar
 
using Pix8u = UChar
 
using Pix8s = Char
 
using Pix16u = UInt16
 
using Pix16s = Int16
 
using Pix32u = UInt32
 
using Pix32s = Int32
 
using Pix32f = Float32
 
using Pix64f = Float64
 
using Pix16f = HalfFloat
 
using BlendPixelHandlerRef = StrongRef< BlendPixelHandlerStruct >
 
using ChannelOffsets = Block< const BITS >
 
using ImageConstBuffer = ImageBufferTemplate< PixelConstBuffer >
 
using ImageMutableBuffer = ImageBufferTemplate< PixelMutableBuffer >
 
using CONVERTPIXELFUNC = Delegate< Result< void >(const PixelMutableBuffer &dst, Int count, const PixelConstBuffer &src, GETPIXELFLAGS flags)>
 
using CONVERTPIXELFUNCSTATIC = Result< void >(*)(const PixelMutableBuffer &dst, Int count, const PixelConstBuffer &src, GETPIXELFLAGS flags, const ChannelOffsets &dstChannelOffset, const ChannelOffsets &srcChannelOffset)
 
using ConvertFuncChannelHelperRef = StrongRef< ConvertFuncChannelHelper >
 
using UpdateRegion = Range< IntVector2d >
 
using BitDepthConfig = const DataType
 
using MediaOutputSelectionHandler = Delegate< Result< SELECTIONHANDLERRESULT >(const MediaStreamRef &stream, const MediaStreamFormat &props)>
 
using MediaSessionProgressCallback = Delegate< void(const ProgressRef &progress, Float percent, const TimeValue &duration, const TimeValue &expectedTotalTime)>
 
using AnimBlendTweenCallback = Delegate< void(const BlendAnimationRef &self, const BlendTweenRef &tween, ANIMBLENDSTATE state, const Data &animValue)>
 
using Complex32 = Complex< Float32 >
 
using Complex64 = Complex< Float64 >
 
using MatrixNxM32 = MatrixNxM< Float32 >
 
using MatrixNxM64 = MatrixNxM< Float64 >
 
using MatrixNxMComplex32 = MatrixNxM< Complex32 >
 
using MatrixNxMComplex64 = MatrixNxM< Complex64 >
 
using PRSMatrix64 = PRSMatrixData< Vector64 >
 
using PRSMatrix32 = PRSMatrixData< Vector32 >
 
using PRSMatrix = PRSMatrixData< Vector >
 
using FbmTableRef = OpaqueRef
 
using FbmTablePtr = OpaqueBase const *
 
using Quaternion32 = Quaternion< Float32 >
 
using Quaternion64 = Quaternion< Float64 >
 
template<typename T >
using enable_if_scalar = typename std::enable_if< STD_IS_REPLACEMENT(scalar, T), T >::type
 
template<typename T >
using enable_if_not_scalar = typename std::enable_if<!STD_IS_REPLACEMENT(scalar, T), T >::type
 
template<typename T >
using enable_if_float = typename std::enable_if< STD_IS_REPLACEMENT(floating_point, T), T >::type
 
template<typename T >
using enable_if_not_float = typename std::enable_if<!STD_IS_REPLACEMENT(floating_point, T), T >::type
 
template<typename T >
using enable_if_integral = typename std::enable_if< STD_IS_REPLACEMENT(integral, T), T >::type
 
template<typename T >
using enable_if_not_integral = typename std::enable_if<!STD_IS_REPLACEMENT(integral, T), T >::type
 
using VariadicInstance = Tuple< Id, DataDictionary >
 
using IconProvider = Delegate< Result< Url >(const CString &)>
 
using SCConversionFunction = Delegate< Result< Data >(const CString &val)>
 
using SCTypeConversion = HashMap< CString, SCConversionFunction >
 
using SQLDatabaseError = IllegalStateError
 
using SubDataPath = BaseArray< Data >
 
using SubDataPathBlock = Block< const Data >
 
using EdgePair = EdgePairTemplate< Int32, NOTOK >
 
using IndexType = Int32
 
using EdgeNeigborPolygons = neighbor::EdgeNeigborPolygonsTemplate< IndexType, LIMIT< IndexType >::MAX, NOTOK >
 
using SimplePolygon = Poly< Int32 >
 
using UVWPolygon = Poly< Vector >
 
using TangentPair = Tuple< Vector, Vector >
 
using TangentPair2d = Tuple< Vector2d, Vector2d >
 
using AioBuffer = BaseArray< Char >
 
using SOCKET = int
 
using ReturnResolveError = Result< void >
 
using SSH_CHANGE_PASSWORD_CALLBACK = void(*)(String &newPassword)
 
typedef Char NETWORKCHAR
 
typedef int SocketT
 
using HandleRequestDelegate = Delegate< Result< void >(const NetworkWebServerRef &server, const NetworkHttpHandlerRef &remoteConnection, const String &file, const DataDictionary &request)>
 
using IndexSelectionType = RangeSet< UInt32, BurstTrieMapSelector< 4, 20 > >
 
using IndexSelection = StrongCOWRef< IndexSelectionType >
 
using WeakNimbusBaseRef = WeakRef< NimbusBaseRef >
 
using NimbusContextGetter = Delegate< Result< Data >(const NimbusBaseRef &nimbus)>
 
using FunctionRegistration = Delegate< Result< void >(py::NativePyCFunctionWithKeywords func)>
 
using NativePyCFunctionTable = Tuple< const Char *, py::NativePyCFunctionWithKeywords >
 
using PyChar = Char
 
using FilterProgressMonitorFunction = Bool(*)(void *userPtr, Float progress)
 
using TestsFinishedDelegate = Delegate< void()>
 
using TestsErrorDelegate = Delegate< void(Result< void >, const maxon::String &line)>
 
using LineDelegate = Delegate< LINEXECUTION(const maxon::String &line, const maxon::Url &location)>
 
using AutoExeArgs = BaseArray< String >
 
template<typename T >
using CFAutoReference = CFStrongRef< T >
 
template<typename T >
using NSAutoReference = NSStrongRef< T >
 
using GridAccessorBase = GridAccessorRef< Generic >
 
using VolumeRayIntersectorBase = VolumeRayIntersectorRef< Generic >
 
using DelegatePointObjectsPair = Pair< Delegate< Result< void >(void *, PointsToVolumeListRef &)>, BaseArray< void * > >
 
using DelegatePointObjectsPairList = BaseArray< DelegatePointObjectsPair >
 

Enumerations

enum class  ASSETBROWSERMODE {
  UNDEFINED ,
  CATEGORIES ,
  ASSETS ,
  KEYWORDSAVAILABLE ,
  KEYWORDSASSIGNED ,
  VERSIONS ,
  DEPENDENCIES ,
  DEPENDANTS ,
  DATABASES
}
 
enum class  ASSETGROUPBY {
  UNDEFINED ,
  CATEGORY ,
  CREATIONDATE ,
  USEDATE ,
  USECOUNT ,
  TYPE ,
  DATABASE ,
  NOTHING ,
  _MAX
}
 
enum class  ASSETSORTBY {
  UNDEFINED ,
  NAME ,
  MODIFICATION_DATE ,
  CREATION_DATE ,
  USEDATE ,
  USE_COUNT ,
  SIZE ,
  RELEVANCE
}
 
enum class  ASSETSORTFIRST {
  UNDEFINED ,
  NONE ,
  FAVORITES ,
  RELEVANT
}
 
enum class  ASSETSORTORDER {
  NONE ,
  ASCENDING ,
  DESCENDING
}
 
enum class  ASSETRELEVANCECONTEXT {
  UNDEFINED ,
  OBJECT_OM ,
  OBJECT_VP ,
  MESH ,
  SPLINE ,
  MATERIAL ,
  UV_EDITOR ,
  UV_VP ,
  NODE ,
  OTHER
}
 
enum class  REPOSITORYSTATE {
  NONE ,
  INTERNAL ,
  MOUNTED ,
  READONLY ,
  DATABASE ,
  WATCHFOLDER ,
  ONLINE ,
  COMPACTABLE ,
  ACTIVE ,
  ERROR
}
 
enum class  FILTERASSETRESULT {
  SKIP ,
  ADD ,
  ADDCATEGORYONLY
}
 
enum class  MASTERFILTER {
  ALL ,
  OBJECTS ,
  MATERIALS ,
  MEDIA ,
  NODES ,
  SCENE_NODES ,
  SCENES ,
  PRESETS ,
  TOOLCOMMANDS ,
  OBJECTCOMMANDS ,
  OTHERCOMMANDS ,
  SPECIAL
}
 
enum class  LENGTHUNITSYSTEM {
  METRIC ,
  IMPERIAL
}
 
enum class  BUILDBROWSERENTRYCOMMAND {
  START ,
  END ,
  RESET ,
  ADD ,
  SELECT
}
 
enum class  COMMAND_ASSET_STATE {
  NONE ,
  ENABLED ,
  CHECKED ,
  HIDDEN ,
  HAS_OPTIONS
}
 
enum class  DOWNLOADSTATE {
  NO ,
  YES ,
  INPROGRESS ,
  ERROR ,
  UNAVAILABLE
}
 
enum class  ASSETLICENSETYPE : UInt64 {
  NONE ,
  ENABLE_IN_SUBSCRIPTION ,
  SHOW_IN_SUBSCRIPTION ,
  ENABLE_IN_PERPETUAL ,
  SHOW_IN_PERPETUAL ,
  ENABLE_IN_TRIAL ,
  SHOW_IN_TRIAL ,
  ENABLE_IN_LITE ,
  SHOW_IN_LITE ,
  ENABLE_IN_STUDENT ,
  SHOW_IN_STUDENT ,
  ENABLE_IN_EDUCATION ,
  SHOW_IN_EDUCATION ,
  ENABLE_IN_CINEWARE ,
  SHOW_IN_CINEWARE ,
  ONLY_IN_MAXONONE ,
  ENABLE_IN_ALL ,
  SHOW_IN_ALL ,
  ALLBITS
}
 
enum class  ASSET_FIND_MODE {
  NONE ,
  LATEST ,
  ALL ,
  WITHOUT_BASES ,
  WITH_DELETED ,
  PREFIX ,
  RANDOMIZED_ORDER ,
  CHECK_CANCELLATION ,
  PRIVATE_QUERY_REPOSITORY_VISIBILITY
}
 
enum class  ASSET_VERSION_VALIDITY {
  VALID ,
  INVALID_HIGHER_VERSION_REQUIRED ,
  INVALID_LOWER_VERSION_REQUIRED
}
 
enum class  ASSET_LICENSE_VALIDITY {
  VALID ,
  INVALID_LICENSE_HIDDEN ,
  INVALID_LICENSE_VISIBLE
}
 
enum class  REPOSITORYINDEXSTATE {
  NONE ,
  PENDING ,
  RUNNING ,
  EXISTS
}
 
enum class  OUTPUTLOCATION {
  BETA ,
  C4D ,
  NET ,
  ALL
}
 
enum class  ASSETINSERTOBJECTMODE {
  ASOBJECT ,
  ASINSTANCE ,
  ASRENDERINSTANCE ,
  ASXREF
}
 
enum class  GENERATESCENEPREVIEWIMAGEFLAGS {
  NONE ,
  ISORIGINALDOCUMENT ,
  FRAMESCENE ,
  PREVIEWRENDER ,
  GEOMETRYONLY ,
  AUTODETECT_RENDERENGINE
}
 
enum class  OPENSAVEASSETDIALOGFLAGS {
  NONE ,
  ALLOW_EDIT_ID ,
  ALLOW_EDIT_NAME ,
  SHOW_VERSION ,
  ALLOW_EMPTY_CATEGORY ,
  SHOW_MAKE_DEFAULT
}
 
enum class  ASSETPOPUPOPTIONS {
  NONE ,
  POPUPMODE ,
  MODAL ,
  EXECUTELOAD ,
  ALLOWDRAGANDDROP ,
  ALLOWPINPOPUP ,
  SUBDIALOG ,
  SHOWCATEGORIESONLY ,
  SHOWKEYWORDSONLY ,
  SHOWCATEGORYLIST ,
  SHOWQUICKTABS ,
  DISPLAYASLIST ,
  HIDEWATCHFOLDERS ,
  COMMANDER
}
 
enum class  VIEW_MODE {
  LIST ,
  GRID
}
 
enum class  COMMANDSTATE {
  DISABLED ,
  ENABLED
}
 
enum class  COMMANDRESULT {
  OK ,
  SKIP ,
  BREAK
}
 
enum class  INTERACTIONTYPE {
  NONE ,
  START ,
  ITERATE ,
  END ,
  REALTIME
}
 
enum class  MOVE_MODE {
  KEEP_SOURCE ,
  DESTRUCT_SOURCE
}
 
enum class  NO_MATCH_TYPE { VALUE }
 
enum class  ENUM_DONT_INITIALIZE { VALUE }
 
enum class  IN_PLACE_TYPE { VALUE }
 
enum class  VALUEKIND : UInt64 {
  NONE ,
  VOID_TYPE ,
  GENERIC ,
  GENERIC_ARITHMETIC ,
  SCALAR ,
  INTEGRAL ,
  FLOATING_POINT ,
  ENUM ,
  ENUM_LIST ,
  ENUM_FLAGS ,
  DATA ,
  DATAPTR ,
  NONVIRTUAL_INTERFACE ,
  VIRTUAL_INTERFACE ,
  REF_OR_POINTER ,
  POINTER ,
  STRONG_REFERENCE ,
  COW_REFERENCE ,
  UNIQUE_REFERENCE ,
  ACOW_REFERENCE ,
  LV_REFERENCE ,
  RV_REFERENCE ,
  TUPLE ,
  STRUCT ,
  SIMD ,
  BLOCK ,
  STRIDED_BLOCK ,
  BASEARRAY ,
  BLOCKARRAY ,
  RESULT ,
  DELEGATE ,
  FUNCTION ,
  CONST_QUALIFIED ,
  SOURCE_LEVEL ,
  DEEP_CONSTNESS ,
  INT_SIZE_OR_LESS ,
  ZERO_INITIALIZED ,
  ORDERED ,
  TRIVIALLY_CONSTRUCTIBLE ,
  TRIVIALLY_DESTRUCTIBLE ,
  TRIVIALLY_COPYABLE ,
  TRIVIALLY_EQUATABLE ,
  TRIVIALLY_HASHABLE ,
  OBJECT_REF ,
  VALUE ,
  ELEMENT_TYPE_AS_ARG ,
  NEVER_NULLPTR ,
  SIGNED ,
  GENERIC_INSTANTIATION ,
  ABSTRACT ,
  NAMED ,
  CONTAINER_REF ,
  GENERIC_CONTAINER ,
  RECURSIVE_CONTAINER ,
  RESOLVED_RECURSIVE_CONTAINER ,
  CONTAINER ,
  EMPTY_CONTAINER ,
  VIRTUAL_TUPLE_CONTAINER ,
  STATIC_ARRAY_CONTAINER ,
  ARRAY_CONTAINER ,
  ARRAY ,
  CONTAINER_MASK ,
  NAMED_TUPLE ,
  CONTAINS_RECURSIVE_CONTAINER ,
  CONTAINS_INVALID_TYPE ,
  BUNDLE ,
  MIN_DERIVED_CONTAINER ,
  MIN_ARRAY_CONTAINER ,
  MAX_ARRAY_CONTAINER ,
  COW_MASK ,
  STRONG_MASK ,
  PTR_MASK ,
  CONTAINER_OR_REF ,
  REFERENCE_MASK ,
  ARITHMETIC_MASK ,
  TUPLE_MASK ,
  TUPLE_INHERIT_MASK ,
  POINTER_FLAGS ,
  QUALIFIER_MASK ,
  CONTAINS_MASK
}
 
enum class  COLLECTION_KIND {
  NONE ,
  ARRAY ,
  SET ,
  MAP
}
 
enum class  SUBSYSTEM {
  UNDEFINED ,
  CONSOLE ,
  WINDOWS
}
 
enum class  APPLICATION_URLTYPE {
  STARTUP_DIR ,
  APPLICATION ,
  APP_EXECUTABLE ,
  CORELIBS_DIR ,
  RESOURCE_DIR ,
  TEMP_DIR ,
  PREFS_DIR ,
  GLOBALPREFS_DIR ,
  DESKTOP_DIR ,
  USER_HOME_DIR ,
  USER_DOCUMENTS_DIR ,
  SYSTEM_PROGRAMS_DIR ,
  CURRENT_WORKING_DIR ,
  CURRENT_MODULE_DIR ,
  CURRENT_MODULE_RESOURCE_DIR ,
  LIBRARY_DIR ,
  PREFS_DIR_STATIC ,
  TESTDATA_DIR
}
 
enum class  APPLICATIONMODE {
  DONTWAIT ,
  KEEPRUNNING ,
  SHUTDOWN
}
 
enum class  APPLICATIONFEATURE {
  NONE ,
  COMMANDLINE ,
  LIBRARY ,
  UI
}
 
enum class  BASEARRAYFLAGS {
  NONE ,
  MOVEANDCOPYOBJECTS ,
  ZEROINITIALIZE
}
 
enum class  BLOCKARRAYFLAGS {
  NONE ,
  MOVEANDCOPYOBJECTS ,
  NOINSERTERASE ,
  GROW_SLOWLY ,
  ZEROINITIALIZE
}
 
enum class  BURSTTRIE_SORT {
  NONE ,
  LINEAR_SEARCH ,
  BINARY_SEARCH
}
 
enum class  BYTEORDER {
  BIG ,
  LITTLE
}
 
enum class  COLLECTION_RESIZE_FLAGS {
  NONE ,
  ON_SHRINK_KEEP_CAPACITY ,
  ON_SHRINK_FIT_TO_SIZE ,
  ON_GROW_RESERVE_CAPACITY ,
  ON_GROW_FIT_TO_SIZE ,
  ON_GROW_UNINITIALIZED ,
  ON_GROW_UNSPECIFIED ,
  ON_RESIZE_UNSPECIFIED ,
  FIT_TO_SIZE ,
  DEFAULT ,
  POD_UNINITIALIZED
}
 
enum class  CONFIGURATION_CATEGORY {
  REGULAR ,
  DEVELOPMENT ,
  MODULE ,
  EXTENSION ,
  IMPLEMENTATION ,
  NONE ,
  SUBSCRIBER
}
 
enum class  CONFIGURATIONENTRY_ORIGIN {
  APPLICATION ,
  CONFIGURATION ,
  ENVIRONMENT ,
  COMMANDLINE
}
 
enum class  CONFIGURATIONENTRY_STATE {
  UNUSED ,
  INVALIDARGUMENT ,
  USED ,
  OUTOFRANGE
}
 
enum class  CONDITIONTOKENTYPE {
  NONE ,
  ATTRIBUTEID ,
  DYN_ATTRIBUTEID ,
  VARIABLE ,
  CONSTANT ,
  FUNCTION ,
  OPERATOR ,
  PARENTHESIS
}
 
enum class  GETDATAFLAGS {
  NONE ,
  INTENT_ENABLING ,
  INTENT_ENABLING_ISCONNECTED ,
  INTENT_ENABLING_GRAPHNODE ,
  INTENT_ENABLING_HASVALUE ,
  INTENT_GET_TRANSLATEDCHILDREN
}
 
enum class  DBVERSION {
  S22 ,
  R23_CONVERTLIMIT ,
  R23_CONVERTENUM ,
  R23_CONVERTENUM2 ,
  R23_DBVERSIONIDTYPE ,
  CURRENT
}
 
enum class  DESCRIPTIONMESSAGECHECKFLAGS {
  NONE ,
  ENABLED ,
  VISIBLE ,
  CHECKED ,
  SORTSUBMENU
}
 
enum class  LOADDESCRIPTIONMODE {
  COMPLETE ,
  OVERWRITTEN
}
 
enum class  PREPAREHELPERFLAGS {
  NONE ,
  INITIALIZE_READ ,
  INITIALIZE_WRITE ,
  FINALIZE_READ ,
  FINALIZE_WRITE ,
  VALIDATE_STATE
}
 
enum class  DATATYPEBUILDERNAME {
  HUMAN_READABLE ,
  CODE_CPP
}
 
enum class  CONVERSION_FLAGS {
  NONE ,
  NARROWING ,
  WIDENING_LOSSY ,
  WIDENING_LOSSLESS ,
  REDUCING ,
  EXPANDING ,
  STRUCT_CAST ,
  ITERATION ,
  INCONVERTIBLE ,
  WIDENING_MASK ,
  NARROWING_REDUCING_MASK
}
 
enum class  GET_DATATYPE_POLICY {
  NONE ,
  GENERIC_FOR_UNKNOWN ,
  ERROR_FOR_UNKNOWN ,
  RESULT_FOR_UNKNOWN_MASK
}
 
enum class  DATATYPEMODE {
  SMALLISPOD ,
  SMALL ,
  BIG
}
 
enum class  INNERMOST_MEMBER : Int32
 
enum class  DAYOFWEEK {
  MONDAY ,
  TUESDAY ,
  WEDNESDAY ,
  THURSDAY ,
  FRIDAY ,
  SATURDAY ,
  SUNDAY
}
 
enum class  DST : Int16 {
  AUTOMATIC ,
  NOTSET ,
  SET
}
 
enum class  JULIANDATE {
  STANDARD ,
  REDUCED ,
  MODIFIED ,
  LEGACY ,
  TRUNCATED ,
  DUBLIN ,
  LILIAN ,
  RATEDIE ,
  UNIXTIME ,
  MARSSOL
}
 
enum class  HARDWAREBREAKPOINTTYPE {
  CODE ,
  READWRITE ,
  WRITE
}
 
enum class  HARDWAREBREAKPOINTSIZE {
  SIZE1 ,
  SIZE2 ,
  SIZE4 ,
  SIZE8
}
 
enum class  NULL_RETURN_REASON {
  NULLPTR ,
  MAKE_WRITABLE_FAILED ,
  UNRESOLVED ,
  NULLIMPL
}
 
enum class  FILEFORMATDETECTIONFLAGS {
  NONE ,
  FASTDETECTION
}
 
enum class  FILEFORMAT_PRIORITY {
  SHIFT_ONE ,
  SHIFT_TEN ,
  FALLBACKFORMAT ,
  GENERALFORMAT ,
  NATIVEFORMAT
}
 
enum class  HASHMAP_ENTRY_LAYOUT {
  HASH_KEY_VALUE ,
  KEY_HASH_VALUE ,
  HASH_VALUE_KEY ,
  HASH_VALUE ,
  KEY_VALUE ,
  VALUE
}
 
enum class  HASHMAP_MODE {
  DEFAULT ,
  SYNCHRONIZED ,
  NO_NONEMPTY_BUCKET_TABLE
}
 
enum class  ASSET_UPDATE_POLICY {
  NEVER ,
  EXPLICIT ,
  IMPLICIT
}
 
enum class  IOARCHIVESTOREMETHOD {
  STORE ,
  DEFLATE
}
 
enum class  IOARCHIVEEXTRACTFLAGS {
  NONE ,
  OVERWRITE_EXISTING_FILE
}
 
enum class  IOBROWSEFLAGS {
  NONE ,
  IS_DIRECTORY ,
  IS_BUNDLE ,
  IS_READONLY ,
  IS_HIDDEN ,
  SUPPORT_REVISIONS ,
  IS_LINK ,
  IS_ENCRYPTED ,
  IS_DELETED ,
  IS_INVISIBLE
}
 
enum class  IOTIMEMODE {
  CREATED ,
  MODIFIED ,
  ACCESSED
}
 
enum class  URLCOMPARE {
  DEFAULT ,
  NORMALIZE ,
  IONORMALIZE ,
  LEGACY ,
  FULL
}
 
enum class  IODETECT {
  ERRORSTATE ,
  NONEXISTENT ,
  UNKNOWN ,
  FILE ,
  LINK ,
  DIRECTORY
}
 
enum class  OPENSTREAMFLAGS {
  NONE ,
  WRITE_DONT_TRUNCATE ,
  ALLOW_SHARED_READ_WRITE_ACCESS ,
  SEEK_TO_END ,
  FULL_DUPLEX ,
  ASK_FOR_REMOVE_WRITE_PROTECTION
}
 
enum class  NORMALIZEFLAGS {
  NONE ,
  SCHEME_BASED ,
  CASE ,
  PATH_SEGMENT ,
  UNICODE_DECOMPOSITION ,
  UNDERLYING ,
  UNDERLYING_RECURSIVE
}
 
enum class  IOATTRIBUTES : UInt {
  NONE ,
  READONLY ,
  HIDDEN ,
  ARCHIVE ,
  LOCKED ,
  OWNER_R ,
  OWNER_W ,
  OWNER_X ,
  GROUP_R ,
  GROUP_W ,
  GROUP_X ,
  PUBLIC_R ,
  PUBLIC_W ,
  PUBLIC_X ,
  RW_MASK ,
  RWX_MASK ,
  MASK_ALL
}
 
enum class  IOSHOWINOSFLAGS {
  NONE ,
  SHOW_IN_EXPLORER ,
  OPEN_IN_EXPLORER
}
 
enum class  JOBGROUPFLAGS {
  DEFAULT ,
  ENQUEUEING_THREAD_WAITS ,
  FINALIZE_ON_WAIT ,
  THREAD_AFFINITY ,
  NO_JOB_DESTRUCTOR ,
  KEEP_JOBS_REFERENCED
}
 
enum class  JOBGROUPADDFLAGS {
  DEFAULT ,
  SLOW_PRODUCER
}
 
enum class  STATICJOBGROUPFLAGS {
  DEFAULT ,
  WILL_RUN_FINALIZER ,
  ENQUEUEING_THREAD_WAITS ,
  THREAD_AFFINITY ,
  NO_JOB_DESTRUCTOR
}
 
enum class  STATICJOBARRAYFLAGS {
  DEFAULT ,
  INITIALIZE_LATER
}
 
enum class  JOBQUEUETYPE {
  MAINTHREAD ,
  NONE ,
  LOWESTPRIORITY ,
  LOWPRIORITY ,
  NORMALPRIORITY ,
  SERVICEIO ,
  THREADLESS
}
 
enum class  JOBQUEUEMODE {
  DEFAULT ,
  SPIN_ON_IDLE ,
  SLEEP_ON_IDLE ,
  DETACH_THREADS ,
  PSEUDO_THREADS
}
 
enum class  LEXERSYMBOL : UChar {
  NONE ,
  ILLEGAL ,
  ENDOFFILE ,
  IDENTIFIER ,
  STRING ,
  STRINGCHR ,
  NUMBER ,
  NEWLINE ,
  CURLYBRACKET_OPEN ,
  CURLYBRACKET_CLOSE ,
  PARENTHESE_OPEN ,
  PARENTHESE_CLOSE ,
  SQUAREBRACKET_OPEN ,
  SQUAREBRACKET_CLOSE ,
  SLASH ,
  EQUAL ,
  COMMA ,
  SEMICOLON ,
  COLON ,
  PLUS ,
  TILDE ,
  PREPROCESSOR ,
  MULTIPLY ,
  PIPE ,
  AMPERSAND ,
  OPERATOR
}
 
enum class  LEXERSYMBOLFLAGS {
  NONE ,
  NO_NUMBER ,
  ALLOWSTRINGS ,
  MINUS_OPERATOR
}
 
enum class  LEXERINITFLAGS {
  NONE ,
  NEED_EOL ,
  REWIND_WHEN_DONE ,
  ALLOW_DOLLAR_IDENT ,
  ALLOW_AT_IDENT ,
  NON_ASCII_IS_IDENT ,
  HASH_COMMENTS ,
  ESCAPE_IN_SINGLE_QUOTED ,
  C_ESCAPE_SEQUENCES ,
  DOUBLEQUOTEESCAPE ,
  SPACESCOMPATIBILITY ,
  C4DSTRCOMPATIBILITY
}
 
enum class  ROTATIONORDER {
  ZXYGLOBAL ,
  ZYXGLOBAL ,
  YXZGLOBAL ,
  YZXGLOBAL ,
  XZYGLOBAL ,
  XYZGLOBAL ,
  YXZLOCAL ,
  XYZLOCAL ,
  ZXYLOCAL ,
  XZYLOCAL ,
  YZXLOCAL ,
  ZYXLOCAL
}
 
enum class  MACHINESTATE {
  NONE ,
  CONNECTION_ERROR ,
  ADDED_MANUALLY ,
  AVAILABLE_ZEROCONF ,
  CONNECTED ,
  ALL
}
 
enum class  NO_VALUE_TYPE { VALUE }
 
enum class  PARALLELFORFLAGS {
  INITTHREADED_FINALIZETHREADED ,
  INITTHREADED_FINALIZESYNC ,
  INITSYNC_FINALIZETHREADED ,
  INITSYNC_FINALIZESYNC ,
  NOINIT_NOFINALIZE
}
 
enum class  PARSERFLAGS {
  NONE ,
  HAS_NO_EOF
}
 
enum class  ACCESSLEVEL {
  UNDEFINED ,
  USERINSTALLATION ,
  ACCOUNT ,
  USER ,
  MACHINE ,
  DEFAULTS ,
  ALL
}
 
enum class  BASESORTFLAGS {
  NONE ,
  MOVEANDCOPYOBJECTS
}
 
enum class  STRINGCONVERSION {
  NONE ,
  ALLOW_MORE_CHARACTERS
}
 
enum class  STRINGCOMPARISON {
  MEMORY ,
  UNICODE_LETTERS ,
  UNICODE_NUMBERS ,
  CASEINSENSITIVE ,
  CASEINSENSITIVE_NUMBERS
}
 
enum class  EXECUTEPROGRAMFLAGS {
  NONE ,
  CAPTURELOGFILE ,
  DONT_DELETE_LOGFILE ,
  HIDE_APPLICATION
}
 
enum class  EXECUTEPROGRAMCALLBACK {
  STARTED ,
  RUNNING ,
  FINISHED ,
  KILLED ,
  CLEANUP_OK ,
  CLEANUP_FAILED
}
 
enum class  WAIT_PROCESS_RESULT {
  FINISHED ,
  RUNNING
}
 
enum class  THREADPRIORITY : Int16 {
  NORMAL ,
  ABOVE ,
  BELOW ,
  LOWEST ,
  BACKGROUND_IDLE
}
 
enum class  WAITMODE {
  DEFAULT ,
  RETURN_ON_CANCEL ,
  PRIVATE_BLOCKING ,
  EXTERNAL_ENQUEUE ,
  DONT_WAIT
}
 
enum class  THREADTYPE {
  MAIN ,
  WORKER ,
  STANDALONE ,
  ALIEN ,
  ASSIMILATED
}
 
enum class  TIMEFORMAT {
  SECONDS ,
  FRAMES ,
  SMPTE ,
  SMPTE_DROPFRAMES
}
 
enum class  NORMALIZATION {
  NFC ,
  NFD ,
  NKDC ,
  NFKD ,
  NFD_HFS
}
 
enum class  CHARACTERTYPE : UChar {
  UNKNOWN ,
  LU ,
  LL ,
  LT ,
  LM ,
  LO ,
  MN ,
  MC ,
  ME ,
  ND ,
  NL ,
  NO ,
  PC ,
  PD ,
  PS ,
  PE ,
  PI ,
  PF ,
  PO ,
  SM ,
  SC ,
  SK ,
  SO ,
  ZS ,
  ZL ,
  ZP ,
  CC ,
  CF ,
  CS ,
  CO ,
  CN
}
 
enum class  BASE_DIMENSION {
  LENGTH ,
  TIME ,
  MASS ,
  TEMPERATURE ,
  AMOUNT_OF_SUBSTANCE ,
  ELECTRIC_CURRENT ,
  LUMINOUS_INTENSITY ,
  ANGLE ,
  SOLID_ANGLE ,
  PRIVATE_COUNT
}
 
enum class  GETBROWSEITERATORFLAGS {
  NONE ,
  NOERRORONOPEN ,
  RESOLVEPATHS
}
 
enum class  CONVERTTOUINAMEFLAGS {
  NONE ,
  NAMEONLY ,
  DIRECTORYONLY ,
  ADDVERSION ,
  CLEARSUFFIX ,
  DONTADDDATABASE
}
 
enum class  URLFILECACHEFLAGS {
  NONE ,
  FORCE_RELOAD
}
 
enum class  COMPARERESULT : int {
  LESS ,
  EQUAL ,
  GREATER ,
  INCOMPARABLE
}
 
enum class  EQUALITY {
  SHALLOW ,
  DEEP
}
 
enum class  TARGETAUDIENCE {
  DEBUGGER ,
  DEVELOPERS ,
  USERS ,
  ALL
}
 
enum class  WRITEMETA {
  DEFAULT ,
  WARNING ,
  CRITICAL ,
  NONEWLINE ,
  UI_SYNC_DRAW
}
 
enum class  OUTPUT {
  NONE ,
  DIAGNOSTIC ,
  WARNING ,
  CRITICAL ,
  PRETTYPRINT ,
  NOLINEBREAK ,
  HEADER
}
 
enum class  ERROR_OK { VALUE }
 
enum class  ERROR_FAILED { VALUE }
 
enum class  ERROR_TYPE {
  OUT_OF_MEMORY ,
  NULLPTR ,
  ILLEGAL_ARGUMENT ,
  ILLEGAL_STATE ,
  NOT_IMPLEMENTED ,
  UNRESOLVED ,
  UNKNOWN
}
 
enum class  MEMORY_OBSERVER_FLAGS : Int {
  DEFAULT ,
  CLAIM_SHARED_OWNERSHIP ,
  CLAIM_EXCLUSIVE_OWNERSHIP ,
  KEEP_OBSERVER ,
  INVOKE_WITH_UNLOCKED_TARGET
}
 
enum class  MEMORY_OBSERVER_STATE : Int {
  DEFAULT ,
  TARGET_IS_LOCKED ,
  TARGET_HAS_EXCLUSIVE_OWNERSHIP
}
 
enum class  BLOCK_CIPHER_MODE : UInt64 {
  ECB ,
  CBC ,
  PCBC ,
  CFB ,
  OFB ,
  CTR ,
  KEEP_STATE
}
 
enum class  WIRE_MODE : UChar {
  NONE ,
  MIN ,
  NORMAL ,
  PROPAGATION ,
  AUTO_PROPAGATION ,
  MAX ,
  REMOVE ,
  ALL ,
  FLAG0 ,
  FLAG1 ,
  IMPLICIT ,
  ALL_INCLUDING_IMPLICIT ,
  INHERIT ,
  FLAGS_MASK ,
  FULL_MASK ,
  CONNECT_DEFAULT ,
  GETCONNECTIONS_DEFAULT
}
 
enum class  CONNECTION_POSITION {
  SOURCE ,
  CENTER ,
  TARGET
}
 
enum class  NODE_KIND {
  NONE ,
  NODE ,
  INPUTS ,
  OUTPUTS ,
  INPORT ,
  OUTPORT ,
  IN_MASK ,
  OUT_MASK ,
  PORTLIST_MASK ,
  PORT_MASK ,
  ALL_MASK
}
 
enum class  IMAGEHIERARCHY {
  TEXTURE ,
  IMAGE ,
  ALPHA ,
  LAYER ,
  MASK ,
  DEEPIMAGEDATA ,
  MAX_ELEMENTS
}
 
enum class  TRANSFORM_COLORS_FLAGS {
  NONE ,
  INVERSE_DIRECTION
}
 
enum class  COLORPROFILEINFO {
  DESCRIPTION ,
  MANUFACTURER ,
  MODEL ,
  COPYRIGHT ,
  NAME ,
  OCIO_CONFIG_PATH
}
 
enum class  COLORCONVERSIONINTENT {
  PERCEPTUAL ,
  RELATIVE_COLORIMETRIC ,
  SATURATION ,
  ABSOLUTE_COLORIMETRIC
}
 
enum class  COLORCONVERSIONFLAGS {
  NONE ,
  BLACKPOINTCOMPENSATION ,
  INVERSE_DIRECTION
}
 
enum class  BLENDPIXELFLAGS { NONE }
 
enum class  CONVERTPIXELFLAGS {
  NONE ,
  FORCECOLORPROFILECONVERSION
}
 
enum class  GETPIXELHANDLERFLAGS {
  NONE ,
  FORCECOLORPROFILECONVERSION ,
  DEEPIMAGE ,
  DONTAPPLYMASK ,
  ALLOW_INVALIDATE_ALPHA
}
 
enum class  GETPIXELFLAGS {
  NONE ,
  DEEPIMAGE
}
 
enum class  SETPIXELHANDLERFLAGS {
  NONE ,
  FORCECOLORPROFILECONVERSION ,
  DEEPIMAGE
}
 
enum class  SETPIXELFLAGS {
  NONE ,
  DEEPIMAGE
}
 
enum class  LAYERSETMODE {
  LAYERS ,
  LAYERMASKS ,
  ALPHAS ,
  LAYERALPHA ,
  DISABLED
}
 
enum class  MEDIAFORMATTYPE {
  UNDEFINED ,
  IMAGE ,
  ALPHA ,
  LAYERFOLDER ,
  LAYER ,
  LAYERADJUSTMENT ,
  LAYERMASK ,
  MIPMAP ,
  DEEPIMAGEDATA
}
 
enum class  MEDIAALPHATYPE {
  UNDEFINED ,
  PREMULTIPLIED ,
  STRAIGHT
}
 
enum class  RLACHANNELS {
  Z ,
  MATERIALID ,
  NODE_ID ,
  UV ,
  NORMAL ,
  REALPIX ,
  COVERAGE ,
  BG ,
  NODE_RENDER_ID ,
  COLOR ,
  TRANSP ,
  VELOC ,
  WEIGHT ,
  MASK ,
  MAXCOUNT
}
 
enum class  RLAFLAGS {
  NONE ,
  Z ,
  MATERIALID ,
  OBJECTBUFFER ,
  UV ,
  NORMAL ,
  ORIGCOLOR ,
  COVERAGE ,
  BG ,
  OBJECTID ,
  COLOR ,
  TRANSPARENCY ,
  SUBPIXEL_WEIGHT ,
  SUBPIXEL_MASK
}
 
enum class  SELECTIONHANDLERRESULT {
  NONE ,
  STRUCTURE ,
  CONTENT_FLAG ,
  STRUCTURE_WITH_CONTENT ,
  ALL
}
 
enum class  MEDIASESSIONFLAGS {
  NONE ,
  RUNONLYANALYZE ,
  FORCELOAD
}
 
enum class  BLEND_MODES {
  ADD ,
  AVERAGE ,
  COLOR ,
  COLORBURN ,
  COLORDODGE ,
  DARKEN ,
  DARKER ,
  DIFFERENCE ,
  DISSOLVE ,
  DIVIDE ,
  EXCLUSION ,
  FREEZE ,
  GLOW ,
  HARDLIGHT ,
  HARDMIX ,
  HEAT ,
  HUE ,
  HYPOT ,
  LEVR ,
  LIGHTEN ,
  LIGHTER ,
  LINEARBURN ,
  LINEARDODGE ,
  LUMINANCE ,
  MULTIPLY ,
  OVER ,
  OVERLAY ,
  PINLIGHT ,
  REFLECT ,
  SATURATION ,
  SCREEN ,
  SOFTLIGHT ,
  SUBTRACT ,
  VIVIDLIGHT ,
  XOR ,
  PASSFOLDER ,
  STAMP
}
 
enum class  ANIMBLENDSTATE {
  NONE ,
  STARTED ,
  RUNNING ,
  FINISHED ,
  CANCELED
}
 
enum class  FFT_FLAGS {
  NONE ,
  CALC_INVERSE ,
  SUPPRESS_PADDING
}
 
enum class  FFT_SUPPORT {
  NONE ,
  TRANSFORM_1D ,
  TRANSFORM_2D ,
  ALWAYS_PADDING
}
 
enum class  GRADIENT_INTERPOLATION_TYPE {
  INVALID ,
  CUBICKNOT ,
  CUBICBIAS ,
  SMOOTHKNOT ,
  LINEARKNOT ,
  NONE ,
  EXP_UP ,
  EXP_DOWN ,
  BLEND
}
 
enum class  NURBSCURVE_CONTINUITY {
  OPEN ,
  CLOSED ,
  PERIODIC
}
 
enum class  NURBSCURVE_KNOTMODE {
  CLAMPED_UNIFORM ,
  CLAMPED_CHORDAL ,
  CLAMPED_CENTRIPETAL ,
  UNCLAMPED_UNIFORM ,
  USER_DEFINED
}
 
enum class  SPLINEMAPPER_KNOT_INTERPOLATION_TYPE {
  BEZIER ,
  LINEAR ,
  CUBIC
}
 
enum class  SPLINEMAPPER_KNOT_FLAGS : Int {
  NONE ,
  BREAK_TANGENTS ,
  LOCK_X ,
  LOCK_Y ,
  LOCK_ANGLE ,
  LOCK_LENGTH ,
  KEEPVISUALANGLE ,
  SELECTED
}
 
enum class  SPLINEMAPPER_SPLINE_TYPE {
  SOFT ,
  EASEIN ,
  EASEOUT ,
  EASEEASE ,
  ZERO ,
  UNIFY
}
 
enum class  SPLINEMAPPER_RANGE_STATE {
  NONE ,
  SET ,
  UISET
}
 
enum class  PRIMITIVETYPE {
  NONE ,
  POINT ,
  EDGE ,
  POLYGON
}
 
enum class  METRICUNIT {
  NONE ,
  KM ,
  M ,
  CM ,
  MM ,
  UM ,
  NM ,
  MILE ,
  YARD ,
  FEET ,
  INCH
}
 
enum class  ANGLEUNIT {
  DEGREE ,
  RADIANS
}
 
enum class  CORENODE_PORT_FLAGS {
  NONE ,
  INPUT_WITHOUT_VALUE ,
  OUTPUT_UNUSED
}
 
enum class  PORT_DIR : Int {
  INPUT ,
  OUTPUT ,
  BEGIN ,
  END
}
 
enum class  IOFORMAT {
  DEFAULT ,
  BINARY ,
  BINARY_COMPRESSED ,
  JSON ,
  XML ,
  JSON_STABLE
}
 
enum class  PROFILER_POINT_TYPE {
  NONE ,
  METHOD_ENTER ,
  METHOD_LEAVE ,
  SCOPE_ENTER ,
  SCOPE_LEAVE ,
  DELTA
}
 
enum class  PROFILER_STATE {
  DISABLED ,
  ENABLED_METHOD_SCOPE ,
  ENABLED_ALL
}
 
enum class  PROFILER_CLOCK_MODE {
  NORMAL ,
  SIMULATED
}
 
enum class  SELECTION_MODE : UChar {
  NEW ,
  ADD ,
  SUBTRACT ,
  TOGGLE
}
 
enum class  SELECTION_STATUS : UChar {
  NONE ,
  SELECTED ,
  IMPLICIT
}
 
enum class  REGPARSEMODE {
  MATCH ,
  CONTAINS ,
  STARTS ,
  ENDS
}
 
enum class  GEOMETRY_TEST_EXACT {
  GEOM_FALSE ,
  GEOM_TRUE ,
  GEOM_PARALLEL ,
  GEOM_ANTIPARALLEL ,
  GEOM_COINCIDENT_PREV ,
  GEOM_COINCIDENT_NEXT ,
  GEOM_COINCIDENT_ALL ,
  GEOM_DEGENERATE ,
  GEOM_INVALID_INPUT
}
 
enum class  LOOP_OVERLAP_STATE {
  INTERSECTING ,
  DISJOINT ,
  A_INSIDE_B ,
  B_INSIDE_A ,
  COINCIDENT ,
  DEGENERATE
}
 
enum class  HTTPCODE {
  CLOSED ,
  FINISHED ,
  CALL_NEXT_HANDLER ,
  PROXYERROR ,
  OK ,
  POST ,
  MOVED ,
  SYNTAX ,
  AUTH ,
  ACCESS ,
  NOTFOUND ,
  PROXYAUTHENTICATIONREQUIRED ,
  INTERNAL ,
  UNKNOWN ,
  GATEWAYTIMEOUT
}
 
enum class  SOCKETMODE {
  READ ,
  WRITE ,
  LISTEN ,
  CONNECT
}
 
enum class  CONNECTIONMODE {
  UNDEFINED ,
  SEND ,
  READ
}
 
enum class  CONNECTIONTYPE {
  LISTENER ,
  INCOMING ,
  OUTGOING
}
 
enum class  PROTOCOL {
  UNSPEC ,
  IPV4 ,
  IPV6
}
 
enum class  WILDCARD_IPV4_ADDRESS_TYPE { VALUE }
 
enum class  WILDCARD_IPV6_ADDRESS_TYPE { VALUE }
 
enum class  SSLSOCKETTYPE {
  CLIENTCONNECTION ,
  SERVERCONNECTION
}
 
enum class  SSLPROTOCOLVERSION {
  TLS1 ,
  TLS11 ,
  TLS12 ,
  TLS
}
 
enum class  SSLCERTREQUIREMENTS {
  NONE ,
  ISOPTIONAL ,
  ISREQUIRED ,
  MODE ,
  VERIFY_AUTHORITY
}
 
enum class  SSLFILETYPE {
  ASN1 ,
  PEM
}
 
enum class  OAUTHSIGNATUREMETHOD {
  NONE ,
  PLAINTEXT ,
  HMAC_SHA1
}
 
enum class  OAUTHHTTPMETHOD {
  NONE ,
  GET ,
  POST
}
 
enum class  OAUTHERRORCODE {
  NO_USERACCOUNT ,
  SERVICE_NOT_AVAILABLE
}
 
enum class  MEDIA {
  UNKNOWN ,
  TEXT ,
  IMAGE ,
  AUDIO ,
  VIDEO ,
  APP ,
  MULTI
}
 
enum class  MEDIASUB {
  UNKNOWN ,
  HTML ,
  HTML_PLAIN ,
  GIF ,
  JPEG ,
  PNG ,
  TIFF ,
  MPEG ,
  QUICKTIME ,
  X_MSVIDEO ,
  RTF ,
  MAC_BINHEX40 ,
  X_STUFFIT ,
  ZIP ,
  OCTET_STREAM ,
  POSTSCRIPT ,
  PDF
}
 
enum class  SMTPRECEIVERFIELD : UChar {
  TO ,
  CC ,
  BCC
}
 
enum class  HTTPMETHOD {
  GET ,
  POST ,
  PUT ,
  DELETE
}
 
enum class  HTTPREQUESTTYPE {
  UNKNOWN ,
  GET ,
  POST
}
 
enum class  WEBSOCKETSTATE {
  NOT_CONNECTED ,
  CONNECTED ,
  CLOSED ,
  ERROR
}
 
enum class  WEBSOCKETTYPE {
  TEXT ,
  BINARY ,
  CLOSE
}
 
enum class  WEBSOCKET_OPCODE : UChar {
  CONTINUE ,
  TEXT ,
  DATA ,
  CLOSE ,
  PING ,
  PONG ,
  ILLEGAL
}
 
enum class  ZEROCONFACTION {
  NONE ,
  RESOLVE ,
  MONITOR
}
 
enum class  ZEROCONFMACHINESTATE {
  ONLINE ,
  OFFLINE ,
  REMOVED ,
  UPDATE
}
 
enum class  ZEROCONFERROR {
  NONE ,
  UNKNOWN ,
  NOSUCHNAME ,
  NOMEMORY ,
  BADPARAM ,
  BADREFERENCE ,
  BADSTATE ,
  BADFLAGS ,
  UNSUPPORTED ,
  NOTINITIALIZED ,
  ALREADYREGISTERED ,
  NAMECONFLICT ,
  INVALID ,
  FIREWALL ,
  INCOMPATIBLE ,
  BADINTERFACEINDEX ,
  REFUSED ,
  NOSUCHRECORD ,
  NOAUTH ,
  NOSUCHKEY ,
  NATTRAVERSAL ,
  DOUBLENAT ,
  BADTIME ,
  BADSIGNAL ,
  BADKEY ,
  TRANSIENT ,
  SERVICENOTRUNNING ,
  NATPORTMAPPINGUNSUPPORTED ,
  NATPORTMAPPINGDISABLED ,
  NOROUTER ,
  POLLINGMODE
}
 
enum class  NIMBUS_PATH {
  STARTNODE ,
  SOLO ,
  MATERIALENDNODE
}
 
enum class  PyStringEncodings {
  Utf8 ,
  Utf16 ,
  Utf32 ,
  PyDecode
}
 
enum class  OWNERSHIP {
  NORMAL ,
  CALLER ,
  CALLEE ,
  CALLER_BUT_COPY
}
 
enum class  Errno : int {
  _EPERM ,
  _ENOENT ,
  _ESRCH ,
  _EINTR ,
  _EIO ,
  _ENXIO ,
  _E2BIG ,
  _ENOEXEC ,
  _EBADF ,
  _ECHILD ,
  _EAGAIN ,
  _ENOMEM ,
  _EACCES ,
  _EFAULT ,
  _ENOTBLK ,
  _EBUSY ,
  _EEXIST ,
  _EXDEV ,
  _ENODEV ,
  _ENOTDIR ,
  _EISDIR ,
  _EINVAL ,
  _ENFILE ,
  _EMFILE ,
  _ENOTTY ,
  _ETXTBSY ,
  _EFBIG ,
  _ENOSPC ,
  _ESPIPE ,
  _EROFS ,
  _EMLINK ,
  _EPIPE ,
  _EDOM ,
  _ERANGE ,
  _EDEADLK ,
  _ENAMETOOLONG ,
  _ENOLCK ,
  _ENOSYS ,
  _ENOTEMPTY ,
  _ELOOP ,
  _EWOULDBLOCK ,
  _ENOMSG ,
  _EIDRM ,
  _ECHRNG ,
  _EL2NSYNC ,
  _EL3HLT ,
  _EL3RST ,
  _ELNRNG ,
  _EUNATCH ,
  _ENOCSI ,
  _EL2HLT ,
  _EBADE ,
  _EBADR ,
  _EXFULL ,
  _ENOANO ,
  _EBADRQC ,
  _EBADSLT ,
  _EDEADLOCK ,
  _EBFONT ,
  _ENOSTR ,
  _ENODATA ,
  _ETIME ,
  _ENOSR ,
  _ENONET ,
  _ENOPKG ,
  _EREMOTE ,
  _ENOLINK ,
  _EADV ,
  _ESRMNT ,
  _ECOMM ,
  _EPROTO ,
  _EMULTIHOP ,
  _EDOTDOT ,
  _EBADMSG ,
  _EOVERFLOW ,
  _ENOTUNIQ ,
  _EBADFD ,
  _EREMCHG ,
  _ELIBACC ,
  _ELIBBAD ,
  _ELIBSCN ,
  _ELIBMAX ,
  _ELIBEXEC ,
  _EILSEQ ,
  _ERESTART ,
  _ESTRPIPE ,
  _EUSERS ,
  _ENOTSOCK ,
  _EDESTADDRREQ ,
  _EMSGSIZE ,
  _EPROTOTYPE ,
  _ENOPROTOOPT ,
  _EPROTONOSUPPORT ,
  _ESOCKTNOSUPPORT ,
  _EOPNOTSUPP ,
  _EPFNOSUPPORT ,
  _EAFNOSUPPORT ,
  _EADDRINUSE ,
  _EADDRNOTAVAIL ,
  _ENETDOWN ,
  _ENETUNREACH ,
  _ENETRESET ,
  _ECONNABORTED ,
  _ECONNRESET ,
  _ENOBUFS ,
  _EISCONN ,
  _ENOTCONN ,
  _ESHUTDOWN ,
  _ETOOMANYREFS ,
  _ETIMEDOUT ,
  _ECONNREFUSED ,
  _EHOSTDOWN ,
  _EHOSTUNREACH ,
  _EALREADY ,
  _EINPROGRESS ,
  _ESTALE ,
  _EUCLEAN ,
  _ENOTNAM ,
  _ENAVAIL ,
  _EISNAM ,
  _EREMOTEIO ,
  _EDQUOT ,
  _ENOMEDIUM ,
  _EMEDIUMTYPE ,
  _ECANCELED ,
  _ENOKEY ,
  _EKEYEXPIRED ,
  _EKEYREVOKED ,
  _EKEYREJECTED ,
  _EOWNERDEAD ,
  _ENOTRECOVERABLE
}
 
enum class  CONTAINS : int {
  _FOUND ,
  _NOTFOUND ,
  _ERROR
}
 
enum class  VMSETTINGS {
  MOVE_ERRORS_TO_RESULT ,
  USE_AUTO_GIL
}
 
enum class  VMINITSETTINGS {
  CPYTHON_ADDITIONAL_SYS_PATH ,
  CPYTHON_INTERPRETERFLAGS ,
  CPYTHON_SUBINTERPRETER ,
  PYPY_EXECUTABLE
}
 
enum class  ERRORHANDLING {
  PRINT ,
  CLEAR ,
  REDIRECT
}
 
enum class  DEFAULTRUNTIME {
  NONE ,
  DEBUG_3_VS2015 ,
  RELEASE_3_VS2015 ,
  DEBUG_3 ,
  RELEASE_3 ,
  DEFAULT_3 ,
  DEFAULT
}
 
enum class  LINEXECUTION {
  RUN ,
  SKIP
}
 
enum class  GRIDTYPE {
  NONE ,
  FLOAT ,
  DOUBLE ,
  INT32 ,
  INT64 ,
  INTVECTOR32 ,
  VECTOR32 ,
  VECTOR64 ,
  STRING ,
  BOOLEAN
}
 
enum class  GRIDCLASS {
  NONE ,
  SDF ,
  FOG ,
  STAGGERED ,
  UNKNOWN
}
 
enum class  VECTORGRIDTYPE {
  INVARIANT ,
  COVARIANT ,
  COVARIANT_NORMALIZE ,
  CONTRAVARIANT_RELATIVE ,
  CONTRAVARIANT_ABSOLUTE
}
 
enum class  NANOVDBPRECISION {
  FP4 ,
  FP8 ,
  FP16 ,
  FPN ,
  FLOAT
}
 
enum class  VOLUMESAMPLER {
  NEAREST ,
  LINEAR ,
  QUADRATIC
}
 
enum class  ITERATORTYPE {
  ALL ,
  ON ,
  OFF
}
 
enum class  TREEVOXELLEVEL {
  ROOT ,
  TWO ,
  THREE ,
  LEAF
}
 
enum class  VOLUME_RAY_TYPE {
  WORLD_SPACE ,
  INDEX_SPACE
}
 
enum class  POLYGONCONVERSIONFLAGS {
  NONE ,
  UNSIGNED_DISTANCE_FIELD ,
  DISABLE_INTERSECTING_VOXEL_REMOVAL ,
  DISABLE_RENORMALIZATION ,
  DISABLE_NARROW_BAND_TRIMMING
}
 
enum class  MIXVECTORTYPE {
  NONE ,
  NORMAL ,
  ADD ,
  SUBTRACT ,
  CROSS
}
 
enum class  SDFFILTERTYPE {
  NONE ,
  GAUSSIAN ,
  DILATE ,
  ERODE ,
  MEANVALUE ,
  MEDIANVALUE ,
  MEANCURVATURE ,
  LAPLACIANFLOW ,
  RENORMALIZE ,
  OPEN ,
  CLOSE ,
  TRACK ,
  RESIZE
}
 
enum class  FILTERTYPE {
  NONE ,
  GAUSSIAN ,
  MEANVALUE ,
  MEDIANVALUE ,
  ADD ,
  REMAP ,
  CURVEREMAP ,
  MULTIPLY ,
  ABS ,
  INVERT
}
 
enum class  VECTORFILTERTYPE {
  NONE ,
  GAUSSIAN ,
  MEANVALUE ,
  MEDIANVALUE ,
  CURL ,
  NORMALIZE ,
  INVERT ,
  SCALE ,
  ROTATE
}
 
enum class  FILTERACCURACY {
  NONE ,
  FIRST ,
  SECOND ,
  THIRD ,
  WENO5 ,
  HJWENO5
}
 
enum class  BOOLTYPE {
  NONE ,
  UNION ,
  DIFF ,
  INTERSECT
}
 
enum class  MIXTYPE {
  NONE ,
  NORMAL ,
  MAX ,
  MIN ,
  ADD ,
  SUBTRACT ,
  MULTIPLY ,
  DIVIDE
}
 
enum class  RESAMPLEINTERPOLATIONTYPE {
  NONE ,
  NEAREST ,
  LINEAR ,
  QUADRATIC
}
 
enum class  FIELDLAYER_FLAG {
  NONE ,
  SKIP ,
  HIDE ,
  MODIFYDATA ,
  PRESERVEALPHA ,
  NOCHILDVALUE ,
  NOCHILDCOLOR ,
  NOCHILDDIRECTION ,
  TEMPORARY ,
  NOCHILDROTATION
}
 

Functions

 MAXON_REGISTRY (Class< AutoWeightRef >, AutoWeightAlgos, "net.maxon.animation.registry.autoweights")
 
enum maxon::ASSETBROWSERMODE MAXON_ENUM_LIST (ASSETBROWSERMODE)
 
enum maxon::ASSETGROUPBY MAXON_ENUM_LIST (ASSETGROUPBY)
 
enum maxon::ASSETSORTBY MAXON_ENUM_LIST (ASSETSORTBY)
 
enum maxon::ASSETSORTFIRST MAXON_ENUM_LIST (ASSETSORTFIRST)
 
enum maxon::ASSETSORTORDER MAXON_ENUM_LIST (ASSETSORTORDER)
 
enum maxon::ASSETRELEVANCECONTEXT MAXON_ENUM_LIST (ASSETRELEVANCECONTEXT)
 
enum maxon::REPOSITORYSTATE MAXON_ENUM_FLAGS (REPOSITORYSTATE)
 
enum maxon::FILTERASSETRESULT MAXON_ENUM_LIST (FILTERASSETRESULT)
 
enum maxon::MASTERFILTER MAXON_ENUM_LIST (MASTERFILTER)
 
enum maxon::LENGTHUNITSYSTEM MAXON_ENUM_LIST (LENGTHUNITSYSTEM)
 
enum maxon::BUILDBROWSERENTRYCOMMAND MAXON_ENUM_LIST (BUILDBROWSERENTRYCOMMAND)
 
enum maxon::COMMAND_ASSET_STATE MAXON_ENUM_FLAGS (COMMAND_ASSET_STATE)
 
 MAXON_DATATYPE (AssetDatabaseStruct, "net.maxon.datatype.assetdatabasestruct")
 
enum maxon::DOWNLOADSTATE MAXON_ENUM_LIST (DOWNLOADSTATE)
 
 MAXON_DATATYPE (DragAndDropDataAssetArray, "net.maxon.datatype.draganddropdataassetarray")
 
 MAXON_REGISTRY (AssetRenaming, AssetRenamings, "net.maxon.registry.assetrenamings")
 
class DataDescription MAXON_FORWARD ("maxon/datadescription.h")
 
class DataDescriptionDefinition MAXON_FORWARD ("maxon/datadescriptiondefinition.h")
 
enum maxon::ASSETLICENSETYPE UInt64 MAXON_ENUM_FLAGS (ASSETLICENSETYPE)
 
 MAXON_DATATYPE (AssetDependencyStruct, "net.maxon.datatype.asset.dependencystruct")
 
class OutputStreamRef MAXON_FORWARD ("maxon/iostreams.h")
 
 MAXON_DECLARATION (Class< AssetType >, AssetTypeBaseComponent, "net.maxon.component.assettypebase")
 
 MAXON_REGISTRY (AssetType, AssetTypes, "net.maxon.registry.assettypes")
 
enum maxon::ASSET_FIND_MODE MAXON_ENUM_FLAGS (ASSET_FIND_MODE)
 
enum maxon::ASSET_VERSION_VALIDITY MAXON_ENUM_LIST (ASSET_VERSION_VALIDITY)
 
enum maxon::ASSET_LICENSE_VALIDITY MAXON_ENUM_LIST (ASSET_LICENSE_VALIDITY)
 
 MAXON_DECLARATION (ComponentDescriptor, AssetBaseComponent, "net.maxon.component.assetbase")
 
enum maxon::REPOSITORYINDEXSTATE MAXON_ENUM_LIST (REPOSITORYINDEXSTATE)
 
 MAXON_REGISTRY (BuiltinAssetLoaderNew, BuiltinAssetLoadersNew, "net.maxon.registry.builtinassetloaders2")
 
 MAXON_REGISTRY (BuiltinAssetLoader, BuiltinAssetLoaders, "net.maxon.registry.builtinassetloaders")
 
 MAXON_REGISTRY (Class< AssetRepositoryRef >, AssetRepositoryTypes, "net.maxon.registry.assetrepositorytypes")
 
 MAXON_DECLARATION (Class< AssetRepositoryRef >, AssetRepositoryDecoratorBaseClass, "net.maxon.class.assetrepositorydecoratorbase")
 
 MAXON_DECLARATION (Class< AssetRepositoryRef >, WeakAssetRepositoryDecoratorClass, "net.maxon.class.weakassetrepositorydecorator")
 
Url GetAssetUrl (const DndAsset &asset)
 
Result< void > UpdateAssetUsage (const AssetDescription &asset, Bool incCount=true, Bool updateDate=true)
 
Result< IdAndVersionIdToIdAndVersion (const Id &id)
 
Result< IdIdAndVersionToId (const IdAndVersion &assetId)
 
Result< Tuple< AssetRepositoryRef, IdAndVersion, Bool > > IdToIdAndVersionWithRepository (const Id &id, const AssetRepositoryRef &lookupRepository)
 
Result< IdIdAndVersionToIdWithRepository (const IdAndVersion &assetId, const AssetRepositoryRef &repository)
 
 MAXON_DATATYPE (StoreAssetStruct, "net.maxon.datatype.storeassetstruct")
 
 MAXON_DATATYPE (ResolveAssetDependenciesStruct, "net.maxon.datatype.resolveassetdependenciesstruct")
 
 MAXON_DATATYPE (AddAssetDepencendyStruct, "net.maxon.datatype.addassetdepencendystruct")
 
 MAXON_DECLARATION (Class< BasePresetAssetType >, AssetTypeBasePresetClass, "net.maxon.class.assettypepresetbase")
 
 MAXON_DECLARATION (Class< BasePresetAsset >, BasePresetAssetClass, "net.maxon.class.basepresetasset")
 
 MAXON_ATTRIBUTE (void, AssetCategoryUncategorized, "net.maxon.assetcategory.uncategorized")
 
 MAXON_ATTRIBUTE (void, AssetCategoryWatchFolders, "category@5846c0689c0248cfa54bffed866571ce")
 
template<typename T , typename CALLBACK >
Result< T > GetDerivedMetaData (const AssetDescription &asset, const InternedId &metaId, const CString &externalStamp, CALLBACK &&callback)
 
 MAXON_DECLARATION (LazyLanguageStringDataDescriptionDefinition, LazyLanguageStringDataDescriptionDefinitionClass, "net.maxon.class.lazylanguagestringdatadescriptiondefinition")
 
 MAXON_DECLARATION (LazyLanguageDictionary, LazyLanguageDictionaryClass, "net.maxon.class.lazylanguagedictionary")
 
 MAXON_ATTRIBUTE (void, AssetCategorySmartSearch, "net.maxon.asset.category.smartsearches")
 
 MAXON_DATATYPE (C4DBaseDocumentType, "net.maxon.datatype.c4dbasedocument")
 
 MAXON_DATATYPE (C4DBaseObjectType, "net.maxon.datatype.c4dbaseobject")
 
 MAXON_DATATYPE (C4DPolyObjectType, "net.maxon.datatype.c4dpolyobject")
 
 MAXON_DATATYPE (C4DPolyLineObjectType, "net.maxon.datatype.c4dpolylineobject")
 
 MAXON_DATATYPE (C4DSplineObjectType, "net.maxon.datatype.c4dsplineobject")
 
constexpr const maxon::CharDT_C4DBaseDocumentType_CppName ()
 
constexpr const maxon::CharDT_C4DBaseObjectType_CppName ()
 
constexpr const maxon::CharDT_C4DPolyObjectType_CppName ()
 
constexpr const maxon::CharDT_C4DPolyLineObjectType_CppName ()
 
constexpr const maxon::CharDT_C4DSplineObjectType_CppName ()
 
enum maxon::OUTPUTLOCATION MAXON_ENUM_FLAGS (OUTPUTLOCATION)
 
enum maxon::ASSETINSERTOBJECTMODE MAXON_ENUM_LIST (ASSETINSERTOBJECTMODE)
 
enum maxon::GENERATESCENEPREVIEWIMAGEFLAGS MAXON_ENUM_FLAGS (GENERATESCENEPREVIEWIMAGEFLAGS)
 
enum maxon::OPENSAVEASSETDIALOGFLAGS MAXON_ENUM_FLAGS (OPENSAVEASSETDIALOGFLAGS)
 
enum maxon::ASSETPOPUPOPTIONS MAXON_ENUM_FLAGS (ASSETPOPUPOPTIONS)
 
enum maxon::VIEW_MODE MAXON_ENUM_LIST (VIEW_MODE)
 
Result< CodeExchangerRef > GetActiveCE ()
 
Result< void > StoreActiveCE (CodeExchangerRef ce)
 
 MAXON_REGISTRY (Class< CodeExchangerRef >, CodeExchangers, "net.maxon.registry.codeexchanger")
 
 MAXON_DATATYPE (CommandGetStateDelegate, "net.maxon.hybrid.datatype.commandgetstate")
 
 MAXON_REGISTRY (CommandGetStateDelegate, CommandGetStateDelegates, "net.maxon.hybrid.command.getstates")
 
 MAXON_DATATYPE (CreateMaterialWithDataDelegate, "net.maxon.hybrid.datatype.creatematerialwithdatadelegate")
 
 MAXON_REGISTRY (CreateMaterialWithDataDelegate, CreateMaterialWithDataDelegates, "net.maxon.hybrid.command.creatematerialwithdata")
 
 MAXON_DATATYPE (CreateDefaultMaterialDelegate, "net.maxon.hybrid.datatype.createdefaultmaterialdelegate")
 
 MAXON_REGISTRY (CreateDefaultMaterialDelegate, CreateDefaultMaterialDelegates, "net.maxon.hybrid.command.createdefaultmaterials")
 
Result< PythonElementBaseRef > GetPyElemFromNode (FactoryInterface::ConstPtr factory, BaseList2D *bl)
 
 MAXON_DECLARATION (Class< PythonElementBaseRef >, PythonElementBaseClass, "net.maxon.class.python_element.base")
 
 MAXON_DECLARATION (PyBaseElementFactoryType, PyBaseElementFactory, "net.maxon.factory.python_element.base")
 
 MAXON_DECLARATION (Class< PythonElementEmbeddedRef >, PythonEmbeddedClass, "net.maxon.class.python_element.embedded")
 
 MAXON_DECLARATION (PyEmbeddedElementFactoryType, PyEmbeddedElementFactory, "net.maxon.factory.python_element.embedded")
 
 MAXON_DECLARATION (Class< PythonElementBaseRef >, PythonDirectoryClass, "net.maxon.class.python_element.directory")
 
 MAXON_DECLARATION (PyDirectoryElementFactoryType, PyDirectoryElementFactory, "net.maxon.factory.python_element.directory")
 
 MAXON_DECLARATION (Class< PythonElementScriptRef >, PythonScriptClass, "net.maxon.class.python_element.script")
 
 MAXON_DECLARATION (PyScriptElementFactoryType, PyScriptElementFactory, "net.maxon.factory.python_element.script")
 
 MAXON_REGISTRY (Class< PythonBaseList2DDetectorRef >, PyBaseList2DDetectors, "net.maxon.registry.python_baselist2d_detector")
 
 MAXON_DECLARATION (Class< PyElementManagerRef >, PyElementManager, "net.maxon.py_element_manager_interface")
 
 MAXON_REGISTRY (UiConversion, UiConversions, "net.maxon.image.registry.uiconversions")
 
 MAXON_DECLARATION (maxon::Class< WebSocketJsonCodeExchangerRef >, WebSocketJsonCodeExchanger, "net.maxonsdk.class.codeexchanger.websocket_json")
 
enum maxon::COMMANDSTATE MAXON_ENUM_LIST (COMMANDSTATE)
 
enum maxon::COMMANDRESULT MAXON_ENUM_LIST (COMMANDRESULT)
 
enum maxon::INTERACTIONTYPE MAXON_ENUM_LIST (INTERACTIONTYPE, "net.maxon.command.interationtype")
 
template<typename T = void, typename KEY >
static Tuple< InternedId, DataParam (KEY &&key, T &&data)
 
enum MAXON_WARN_UNUSED_CLASS maxon::COMMAND_ACTION_STATE MAXON_ENUM_LIST (COMMAND_ACTION_STATE)
 
 MAXON_DATATYPE (CommandCacheData, "net.maxon.datatype.commandcachedata", MAXON_IMPLEMENTATION_MODULE("net.maxon.command"))
 
 MAXON_DATATYPE (CommandCacheMap, "net.maxon.datatype.commandcachemap", MAXON_IMPLEMENTATION_MODULE("net.maxon.command"))
 
 MAXON_REGISTRY (Class< CommandDataRef >, CommandDataClasses, "net.maxon.command.registry.commanddataclasses")
 
 MAXON_REGISTRY (Class< LegacyCommandDataRef >, LegacyCommandDataClasses, "net.maxon.command.registry.legacycommanddataclasses")
 
 MAXON_REGISTRY (CommandClass, CommandClasses, "net.maxon.command.registry.commandclasses")
 
 MAXON_REGISTRY (LegacyCommandClass, LegacyCommand, "net.maxon.command.registry.legacycommandclass")
 
 MAXON_REGISTRY (MigratedCommandClass, MigratedCommand, "net.maxon.command.registry.migratedcommandclass")
 
 MAXON_REGISTRY (CommandInteractionClass, CommandInteraction, "net.maxon.command.registry.commandinteractionclass")
 
 MAXON_REGISTRY (CommandDescriptionClass, CommandDescription, "net.maxon.command.registry.commanddescriptionclass")
 
 MAXON_REGISTRY (CommandConversionClass, CommandConversionClasses, "net.maxon.command.registry.commandconversionclasses")
 
 MAXON_REGISTRY (Class< CommandCacheRef >, CommandCacheClasses, "net.maxon.command.registry.commandcacheclasses")
 
 MAXON_DECLARATION (Class< CommandObserverRef >, CommandObserverObjectClass, "net.maxon.command.class.observer", MAXON_IMPLEMENTATION_MODULE("net.maxon.command"))
 
 MAXON_DATATYPE (InvocationState, "net.maxon.datatype.command.invokationstate", MAXON_IMPLEMENTATION_MODULE("net.maxon.command"))
 
 MAXON_REGISTRY (NO_VALUE_TYPE, MemoizationTypes, "net.maxon.registry.memoization")
 
template<typename T >
std::false_type TestForBeginFunction (OverloadRank0)
 
template<typename T >
std::false_type TestForEndFunction (OverloadRank0)
 
template<typename ITERATOR , typename SENTINEL , typename ... ARGS, typename = typename std::enable_if<!IsIterable<ITERATOR>::value>::type>
auto ConstructElements (ITERATOR first, SENTINEL sentinel, const ARGS &... args) -> ITERATOR
 
template<typename ITERABLE , typename ... ARGS, typename = typename std::enable_if<IsIterable<ITERABLE>::value>::type>
auto ConstructElements (ITERABLE &&iterable, const ARGS &... args) -> decltype(begin(iterable))
 
template<typename ITERATOR , typename SENTINEL , typename = typename std::enable_if<!IsIterable<ITERATOR>::value>::type>
auto DestructElements (ITERATOR first, SENTINEL sentinel) -> ITERATOR
 
template<typename ITERABLE , typename = typename std::enable_if<IsIterable<ITERABLE>::value>::type>
auto DestructElements (ITERABLE &&iterable) -> decltype(begin(iterable))
 
template<typename ITERATOR , typename SENTINEL , typename DEST_ITERATOR >
auto Copy (ITERATOR first, SENTINEL sentinel, DEST_ITERATOR dest) -> Result< DEST_ITERATOR >
 
template<typename ITERABLE , typename DEST_ITERATOR >
auto Copy (const ITERABLE &iterable, DEST_ITERATOR dest) -> Result< DEST_ITERATOR >
 
template<typename ITERATOR , typename SENTINEL , typename DEST_ITERATOR , typename PREDICATE >
auto CopyIf (ITERATOR first, SENTINEL sentinel, DEST_ITERATOR dest, PREDICATE pred) -> Result< DEST_ITERATOR >
 
template<typename ITERABLE , typename DEST_ITERATOR , typename PREDICATE >
auto CopyIf (const ITERABLE &iterable, DEST_ITERATOR dest, PREDICATE pred) -> Result< DEST_ITERATOR >
 
template<typename ITERATOR , typename SENTINEL , typename DEST_ITERATOR >
auto CopyToUninitialized (ITERATOR first, SENTINEL sentinel, DEST_ITERATOR dest) -> Result< DEST_ITERATOR >
 
template<typename ITERABLE , typename DEST_ITERATOR >
auto CopyToUninitialized (const ITERABLE &iterable, DEST_ITERATOR dest) -> Result< DEST_ITERATOR >
 
template<typename ITERATOR , typename SENTINEL , typename DEST_ITERATOR , typename PREDICATE >
auto CopyToUninitializedIf (ITERATOR first, SENTINEL sentinel, DEST_ITERATOR dest, PREDICATE pred) -> Result< DEST_ITERATOR >
 
template<typename ITERABLE , typename DEST_ITERATOR , typename PREDICATE >
auto CopyToUninitializedIf (const ITERABLE &iterable, DEST_ITERATOR dest, PREDICATE pred) -> Result< DEST_ITERATOR >
 
enum maxon::MOVE_MODE MAXON_ENUM_LIST (MOVE_MODE)
 
template<MOVE_MODE MODE = MOVE_MODE::KEEP_SOURCE, typename ITERATOR , typename SENTINEL , typename DEST_ITERATOR >
auto Move (ITERATOR first, SENTINEL sentinel, DEST_ITERATOR dest) -> DEST_ITERATOR
 
template<MOVE_MODE MODE = MOVE_MODE::KEEP_SOURCE, typename ITERABLE , typename DEST_ITERATOR >
auto Move (ITERABLE &&iterable, DEST_ITERATOR dest) -> DEST_ITERATOR
 
template<MOVE_MODE MODE = MOVE_MODE::KEEP_SOURCE, typename ITERATOR , typename SENTINEL , typename DEST_ITERATOR , typename PREDICATE >
auto MoveIf (ITERATOR first, SENTINEL sentinel, DEST_ITERATOR dest, PREDICATE pred) -> DEST_ITERATOR
 
template<MOVE_MODE MODE = MOVE_MODE::KEEP_SOURCE, typename ITERABLE , typename DEST_ITERATOR , typename PREDICATE >
auto MoveIf (ITERABLE &&iterable, DEST_ITERATOR dest, PREDICATE pred) -> DEST_ITERATOR
 
template<MOVE_MODE MODE = MOVE_MODE::KEEP_SOURCE, typename ITERATOR , typename SENTINEL , typename DEST_ITERATOR >
auto MoveToUninitialized (ITERATOR first, SENTINEL sentinel, DEST_ITERATOR dest) -> DEST_ITERATOR
 
template<MOVE_MODE MODE = MOVE_MODE::KEEP_SOURCE, typename ITERABLE , typename DEST_ITERATOR >
auto MoveToUninitialized (ITERABLE &&iterable, DEST_ITERATOR dest) -> DEST_ITERATOR
 
template<MOVE_MODE MODE = MOVE_MODE::KEEP_SOURCE, typename ITERATOR , typename SENTINEL , typename DEST_ITERATOR , typename PREDICATE >
auto MoveToUninitializedIf (ITERATOR first, SENTINEL sentinel, DEST_ITERATOR dest, PREDICATE pred) -> DEST_ITERATOR
 
template<MOVE_MODE MODE = MOVE_MODE::KEEP_SOURCE, typename ITERABLE , typename DEST_ITERATOR , typename PREDICATE >
auto MoveToUninitializedIf (ITERABLE &&iterable, DEST_ITERATOR dest, PREDICATE pred) -> DEST_ITERATOR
 
template<typename ITERABLE , typename T >
auto Fill (ITERABLE &&iterable, const T &value) -> decltype(begin(iterable))
 
template<typename ITERATOR , typename SENTINEL , typename GENERATOR >
auto Generate (ITERATOR first, SENTINEL sentinel, GENERATOR gen) -> ITERATOR
 
template<typename ITERABLE , typename GENERATOR >
auto Generate (ITERABLE &&iterable, GENERATOR gen) -> decltype(begin(iterable))
 
template<typename ITERATOR , typename SENTINEL , typename PREDICATE >
Bool AllOf (ITERATOR first, SENTINEL sentinel, PREDICATE pred)
 
template<typename ITERABLE , typename PREDICATE >
Bool AllOf (const ITERABLE &iterable, PREDICATE pred)
 
template<typename ITERATOR , typename SENTINEL , typename PREDICATE >
Bool AnyOf (ITERATOR first, SENTINEL sentinel, PREDICATE pred)
 
template<typename ITERABLE , typename PREDICATE >
Bool AnyOf (const ITERABLE &iterable, PREDICATE pred)
 
template<typename ITERATOR , typename SENTINEL , typename PREDICATE >
Bool NoneOf (ITERATOR first, SENTINEL sentinel, PREDICATE pred)
 
template<typename ITERABLE , typename PREDICATE >
Bool NoneOf (const ITERABLE &iterable, PREDICATE pred)
 
template<typename ITERATOR1 , typename SENTINEL1 , typename ITERATOR2 , typename SENTINEL2 >
Bool Equal (ITERATOR1 first1, SENTINEL1 sentinel1, ITERATOR2 first2, SENTINEL2 sentinel2)
 
template<typename ITERABLE1 , typename ITERABLE2 >
Bool Equal (const ITERABLE1 &iterable1, const ITERABLE2 &iterable2)
 
template<typename ITERATOR1 , typename SENTINEL1 , typename ITERATOR2 , typename SENTINEL2 , typename COMPARE >
Bool Equal (ITERATOR1 first1, SENTINEL1 sentinel1, ITERATOR2 first2, SENTINEL2 sentinel2, COMPARE comp)
 
template<typename ITERABLE1 , typename ITERABLE2 , typename COMPARE >
Bool Equal (const ITERABLE1 &iterable1, const ITERABLE2 &iterable2, COMPARE comp)
 
template<typename ITERATOR1 , typename SENTINEL1 , typename ITERATOR2 , typename SENTINEL2 >
auto Mismatch (ITERATOR1 first1, SENTINEL1 sentinel1, ITERATOR2 first2, SENTINEL2 sentinel2) -> Optional< Pair< ITERATOR1, ITERATOR2 >>
 
template<typename ITERABLE1 , typename ITERABLE2 >
auto Mismatch (ITERABLE1 &&iterable1, ITERABLE2 &&iterable2) -> Optional< Pair< decltype(begin(iterable1)), decltype(begin(iterable2))>>
 
template<typename ITERATOR1 , typename SENTINEL1 , typename ITERATOR2 , typename SENTINEL2 , typename COMPARE >
auto Mismatch (ITERATOR1 first1, SENTINEL1 sentinel1, ITERATOR2 first2, SENTINEL2 sentinel2, COMPARE comp) -> Optional< Pair< ITERATOR1, ITERATOR2 >>
 
template<typename ITERABLE1 , typename ITERABLE2 , typename COMPARE >
auto Mismatch (ITERABLE1 &&iterable1, ITERABLE2 &&iterable2, COMPARE comp) -> Optional< Pair< decltype(begin(iterable1)), decltype(begin(iterable2))>>
 
template<typename ITERATOR , typename PREDICATE >
auto Partition (ITERATOR first, ITERATOR last, PREDICATE pred) -> ITERATOR
 
template<typename ITERATOR , typename SENTINEL , typename PREDICATE >
auto Partition (ITERATOR first, SENTINEL sentinel, PREDICATE pred) -> ITERATOR
 
template<typename ITERABLE , typename PREDICATE >
auto Partition (ITERABLE &&iterable, PREDICATE pred) -> decltype(begin(iterable))
 
template<typename ITERATOR , typename PREDICATE >
Bool IsPartitioned (ITERATOR first, ITERATOR last, PREDICATE pred)
 
template<typename ITERATOR , typename SENTINEL , typename PREDICATE >
Bool IsPartitioned (ITERATOR first, SENTINEL sentinel, PREDICATE pred)
 
template<typename ITERABLE , typename PREDICATE >
Bool IsPartitioned (const ITERABLE &iterable, PREDICATE pred)
 
template<typename ITERABLE >
auto Reverse (ITERABLE &&iterable) -> decltype(begin(iterable))
 
template<typename ITERATOR , typename T >
auto LowerBound (ITERATOR first, ITERATOR last, const T &value) -> ITERATOR
 
template<typename ITERATOR , typename T , typename COMPARE >
auto LowerBound (ITERATOR first, ITERATOR last, const T &value, COMPARE comp) -> ITERATOR
 
template<typename ITERATOR , typename SENTINEL , typename T >
auto LowerBound (ITERATOR first, SENTINEL sentinel, const T &value) -> ITERATOR
 
template<typename ITERATOR , typename SENTINEL , typename T , typename COMPARE >
auto LowerBound (ITERATOR first, SENTINEL sentinel, const T &value, COMPARE comp) -> ITERATOR
 
template<typename ITERABLE , typename T >
auto LowerBound (ITERABLE &&iterable, const T &value) -> decltype(begin(iterable))
 
template<typename ITERABLE , typename T , typename COMPARE >
auto LowerBound (ITERABLE &&iterable, const T &value, COMPARE comp) -> decltype(begin(iterable))
 
template<typename ITERATOR , typename T >
auto UpperBound (ITERATOR first, ITERATOR last, const T &value) -> ITERATOR
 
template<typename ITERATOR , typename T , typename COMPARE >
auto UpperBound (ITERATOR first, ITERATOR last, const T &value, COMPARE comp) -> ITERATOR
 
template<typename ITERATOR , typename SENTINEL , typename T >
auto UpperBound (ITERATOR first, SENTINEL sentinel, const T &value) -> ITERATOR
 
template<typename ITERATOR , typename SENTINEL , typename T , typename COMPARE >
auto UpperBound (ITERATOR first, SENTINEL sentinel, const T &value, COMPARE comp) -> ITERATOR
 
template<typename ITERABLE , typename T >
auto UpperBound (ITERABLE &&iterable, const T &value) -> decltype(begin(iterable))
 
template<typename ITERABLE , typename T , typename COMPARE >
auto UpperBound (ITERABLE &&iterable, const T &value, COMPARE comp) -> decltype(begin(iterable))
 
template<typename ITERATOR , typename T >
auto BinarySearch (ITERATOR first, ITERATOR last, const T &value) -> Optional< ITERATOR >
 
template<typename ITERATOR , typename SENTINEL , typename T >
auto BinarySearch (ITERATOR first, SENTINEL sentinel, const T &value) -> Optional< ITERATOR >
 
template<typename ITERATOR , typename T , typename COMPARE >
auto BinarySearch (ITERATOR first, ITERATOR last, const T &value, COMPARE comp) -> Optional< ITERATOR >
 
template<typename ITERATOR , typename SENTINEL , typename T , typename COMPARE >
auto BinarySearch (ITERATOR first, SENTINEL sentinel, const T &value, COMPARE comp) -> Optional< ITERATOR >
 
template<typename ITERABLE , typename T >
auto BinarySearch (ITERABLE &&iterable, const T &value) -> decltype(begin(iterable))
 
template<typename ITERABLE , typename T , typename COMPARE >
auto BinarySearch (ITERABLE &&iterable, const T &value, COMPARE comp) -> decltype(begin(iterable))
 
template<typename ITERATOR >
auto Rotate (ITERATOR first, ITERATOR last, ITERATOR newFirst) -> ITERATOR
 
template<typename ITERABLE , typename ITERATOR >
auto Rotate (ITERABLE &&iterable, ITERATOR newFirst) -> ITERATOR
 
template<typename ITERATOR , typename SENTINEL >
auto Rotate (ITERATOR first, SENTINEL sentinel, ITERATOR newFirst) -> ITERATOR
 
template<typename ITERATOR , typename SENTINEL , typename T >
Int Count (ITERATOR first, SENTINEL sentinel, const T &value)
 
template<typename ITERABLE , typename T >
Int Count (ITERABLE &&iterable, const T &value)
 
template<typename ITERATOR , typename SENTINEL , typename PREDICATE >
Int CountIf (ITERATOR first, SENTINEL sentinel, PREDICATE pred)
 
template<typename ITERABLE , typename PREDICATE >
auto CountIf (const ITERABLE &iterable, PREDICATE pred) -> Int
 
template<typename ITERATOR , typename SENTINEL , typename = typename std::enable_if<!IsIterable<ITERATOR>::value>::type>
auto Unique (ITERATOR first, SENTINEL sentinel) -> ITERATOR
 
template<typename ITERABLE >
auto Unique (ITERABLE &&iterable) -> decltype(begin(iterable))
 
template<typename ITERATOR , typename SENTINEL , typename COMPARE >
auto Unique (ITERATOR first, SENTINEL sentinel, COMPARE comp) -> ITERATOR
 
template<typename ITERABLE , typename COMPARE , typename = typename std::enable_if<IsIterable<ITERABLE>::value>::type>
auto Unique (ITERABLE &&iterable, COMPARE comp) -> decltype(begin(iterable))
 
template<typename ITERATOR , typename SENTINEL , typename T >
auto Remove (ITERATOR first, SENTINEL sentinel, const T &value) -> ITERATOR
 
template<typename ITERABLE , typename T >
auto Remove (ITERABLE &&iterable, const T &value) -> decltype(begin(iterable))
 
template<typename ITERABLE , typename PREDICATE >
auto RemoveIf (ITERABLE &&iterable, PREDICATE pred) -> decltype(begin(iterable))
 
template<typename ITERATOR , typename SENTINEL , typename T >
auto Replace (ITERATOR first, SENTINEL sentinel, const T &oldValue, const T &newValue) -> ITERATOR
 
template<typename ITERABLE , typename T >
auto Replace (ITERABLE &&iterable, const T &oldValue, const T &newValue) -> decltype(begin(iterable))
 
template<typename ITERATOR , typename SENTINEL , typename PREDICATE , typename T >
auto ReplaceIf (ITERATOR first, SENTINEL sentinel, PREDICATE pred, const T &newValue) -> ITERATOR
 
template<typename ITERABLE , typename PREDICATE , typename T >
auto ReplaceIf (ITERABLE &&iterable, PREDICATE pred, const T &newValue) -> decltype(begin(iterable))
 
template<typename ITERATOR , typename SENTINEL , typename V , typename BINARYOP >
Fold (ITERATOR first, SENTINEL sentinel, V initialValue, BINARYOP op)
 
template<typename ITERABLE , typename V , typename BINARYOP >
Fold (const ITERABLE &iterable, const V &intitialValue, BINARYOP op)
 
template<typename ITERATOR , typename SENTINEL >
auto MinElement (ITERATOR first, SENTINEL sentinel) -> Optional< ITERATOR >
 
template<typename ITERATOR , typename SENTINEL , typename COMPARE >
auto MinElement (ITERATOR first, SENTINEL sentinel, COMPARE comp) -> Optional< ITERATOR >
 
template<typename ITERABLE >
auto MinElement (ITERABLE &&iterable) -> Optional< decltype(begin(iterable))>
 
template<typename ITERABLE , typename COMPARE >
auto MinElement (ITERABLE &&iterable, COMPARE comp) -> Optional< decltype(begin(iterable))>
 
template<typename ITERATOR , typename SENTINEL >
auto MaxElement (ITERATOR first, SENTINEL sentinel) -> Optional< ITERATOR >
 
template<typename ITERATOR , typename SENTINEL , typename COMPARE >
auto MaxElement (ITERATOR first, SENTINEL sentinel, COMPARE comp) -> Optional< ITERATOR >
 
template<typename ITERABLE >
auto MaxElement (ITERABLE &&iterable) -> Optional< decltype(begin(iterable))>
 
template<typename ITERABLE , typename COMPARE >
auto MaxElement (ITERABLE &&iterable, COMPARE comp) -> Optional< decltype(begin(iterable))>
 
template<typename ITERATOR >
Int GetSequenceLength (ITERATOR first, ITERATOR last)
 
template<typename ITERATOR , typename SENTINEL >
Int GetSequenceLength (ITERATOR first, SENTINEL sentinel)
 
template<typename ITERABLE >
Int GetSequenceLength (const ITERABLE &iterable)
 
enum maxon::NO_MATCH_TYPE MAXON_ENUM_LIST (NO_MATCH_TYPE)
 
template<typename INDEXABLE , typename MATCHER >
static auto CountIfMatch (INDEXABLE &&indexable, MATCHER matcher) -> Match< Int >
 
template<typename ITERATOR , typename SENTINEL , typename MATCHER >
auto LinearSearch (ITERATOR first, SENTINEL sentinel, MATCHER matcher) -> Match< ITERATOR >
 
template<typename ITERABLE , typename MATCHER >
auto LinearSearch (ITERABLE &&iterable, MATCHER matcher) -> Match< decltype(begin(iterable))>
 
template<typename ITERABLE , typename MATCHER >
auto Split (const ITERABLE &iterable, MATCHER matcher) -> Result< BaseArray< ITERABLE >>
 
template<typename INDEXABLE , typename MATCHER >
auto SplitIndex (const INDEXABLE &indexable, IndexPair indexPair, MATCHER matcher) -> Result< BaseArray< Match< Int >>>
 
template<typename INDEXABLE , typename MATCHER >
auto SplitIndex (const INDEXABLE &indexable, MATCHER matcher) -> Result< void >
 
template<Int COUNT, typename ITERABLE , typename MATCHER >
auto SplitToTuple (const ITERABLE &iterable, MATCHER matcher) -> HomogenousTupleType< COUNT, ITERABLE >
 
template<Int COUNT, typename INDEXABLE , typename MATCHER >
auto SplitToTupleIndex (const INDEXABLE &indexable, IndexPair indexPair, MATCHER matcher) -> HomogenousTupleType< COUNT, Match< Int >>
 
template<Int COUNT, typename INDEXABLE , typename MATCHER >
auto SplitToTupleIndex (const INDEXABLE &indexable, MATCHER matcher) -> HomogenousTupleType< COUNT, Match< Int >>
 
template<typename ITERATE_FUNC , typename ITERABLE , typename MATCHER >
auto SplitIterate (ITERATE_FUNC iterFunc, const ITERABLE &iterable, MATCHER matcher) -> Result< Bool >
 
template<typename ITERATE_FUNC , typename INDEXABLE , typename MATCHER >
auto SplitIterateIndex (ITERATE_FUNC iterFunc, const INDEXABLE &indexable, IndexPair indexPair, MATCHER matcher) -> Result< Bool >
 
template<typename ITERATE_FUNC , typename INDEXABLE , typename MATCHER >
auto SplitIterateIndex (ITERATE_FUNC iterFunc, const INDEXABLE &indexable, const MATCHER &matcher) -> Result< Bool >
 
template<typename PRED >
auto ByPredicate (const PRED &pred) -> PredicateMatcher< std::reference_wrapper< const PRED >>
 
template<typename T >
auto ByValue (const T &value) -> PredicateMatcher< ValuePredicate< T >>
 
template<typename T , typename COMPARE >
auto ByValue (const T &value, const COMPARE &comp) -> PredicateMatcher< ValueComparePredicate< T, COMPARE >>
 
template<typename PRED >
auto ByRepeatingPredicate (const PRED &pred) -> RepeatingPredicateMatcher< PRED >
 
template<typename T >
auto ByRepeatingValue (const T &value) -> RepeatingPredicateMatcher< ValuePredicate< T >>
 
template<typename T , typename COMPARE >
auto ByRepeatingValue (const T &value, const COMPARE &comp) -> RepeatingPredicateMatcher< ValueComparePredicate< T, COMPARE >>
 
template<typename SEARCH_SEQ >
auto BySequence (const SEARCH_SEQ &searchSeq) -> SequenceMatcher< SEARCH_SEQ, maxon::details::EqualityCompare< typename std::iterator_traits< decltype(begin(searchSeq))>::value_type, typename std::iterator_traits< decltype(begin(searchSeq))>::value_type >>
 
template<typename SEARCH_SEQ , typename COMPARE >
auto BySequence (const SEARCH_SEQ &searchSeq, const COMPARE &comp) -> SequenceMatcher< SEARCH_SEQ, COMPARE >
 
template<typename ITERABLE1 , typename ITERABLE2 >
auto SetDifference (const ITERABLE1 &firstSet, const ITERABLE2 &secondSet) -> Result< ITERABLE1 >
 
template<typename ITERABLE1 , typename ITERABLE2 , typename APPENDABLE >
auto SetDifference (const ITERABLE1 &firstSet, const ITERABLE2 &secondSet, APPENDABLE &outContainer) -> Result< void >
 
template<typename ITERABLE , typename FINDABLE >
auto UnorderedSetDifference (const ITERABLE &firstSet, const FINDABLE &secondSet) -> Result< ITERABLE >
 
template<typename ITERABLE , typename FINDABLE , typename APPENDABLE >
auto UnorderedSetDifference (const ITERABLE &firstSet, const FINDABLE &secondSet, APPENDABLE &outputContainer) -> Result< void >
 
template<typename ERASABLE , typename ITERABLE >
auto ExcludeSetFromSet (ERASABLE &firstSet, const ITERABLE &secondSet) -> Result< void >
 
template<typename ITERATOR , typename SENTINEL , typename T >
auto Fill (ITERATOR first, SENTINEL sentinel, const T &value) -> ITERATOR
 
template<typename ITERATOR >
auto Reverse (ITERATOR first, ITERATOR last) -> ITERATOR
 
template<typename ITERATOR , typename SENTINEL >
auto Reverse (ITERATOR first, SENTINEL sentinel) -> ITERATOR
 
template<typename ITERATOR , typename SENTINEL , typename PREDICATE >
auto RemoveIf (ITERATOR first, SENTINEL sentinel, PREDICATE pred) -> ITERATOR
 
MAXON_ATTRIBUTE_FORCE_INLINE tm ConvertLocalDateTimeToTM (const LocalDateTime &dateTime)
 
MAXON_ATTRIBUTE_FORCE_INLINE LocalDateTime ConvertTMToLocalDateTime (const tm &st)
 
MAXON_ATTRIBUTE_FORCE_INLINE time_t mktime_r (struct tm *tm)
 
MAXON_ATTRIBUTE_FORCE_INLINE time_t timegm_r (struct tm *tm)
 
 __attribute__ ((always_inline)) const expr Float operator""_f(long double f)
 
template<typename T >
 __attribute__ ((always_inline)) auto AssignCopy(T &dst
 
const StringStringInterface_GetAndCacheConstString (const wchar_t *str, Int len)
 
const StringStringInterface_GetAndCacheConstString (const Char *str, Int len, Int isUtf8)
 
constexpr Bool PrivateIsUtf8 (const char *str, Int len)
 
template<typename T >
String GlobalToString (const T &object, const FormatStatement *formatStatement, Bool checkDataType=true)
 
template<typename T , typename E >
E && MakeDependentExpr (E &&value)
 
enum maxon::ENUM_DONT_INITIALIZE MAXON_ENUM_LIST (ENUM_DONT_INITIALIZE)
 
enum maxon::IN_PLACE_TYPE MAXON_ENUM_LIST (IN_PLACE_TYPE)
 
template<typename TO , typename FROM >
GenericCastReturnType< TO, FROM, false >::type GenericReinterpretCast (FROM &&value)
 
template<typename TO , typename FROM >
GenericCastReturnType< TO, FROM, true >::type GenericUpCast (FROM &&value)
 
template<typename T , Bool ALLOW_NONCONST = false>
DefaultValue ()
 
 Helper (OverloadRank2, T &obj MAXON_MAKE_LIST(PRIVATE_MAXON_DETECT_MEMBER_HELPER1,,,,)) -> decltype(obj. GetMemorySize(MAXON_MAKE_COMMA_LIST(PRIVATE_MAXON_DETECT_MEMBER_HELPER2,,,)))
 
 Helper (OverloadRank1, T &obj MAXON_MAKE_LIST(PRIVATE_MAXON_DETECT_MEMBER_HELPER1,,,,)) -> decltype(GetMemorySize(obj MAXON_MAKE_LIST(PRIVATE_MAXON_DETECT_MEMBER_HELPER3,,,,)))
 
 Helper (T &obj MAXON_MAKE_LIST(PRIVATE_MAXON_DETECT_MEMBER_HELPER1,,,,)) -> decltype(MAXON_CONCAT(GetMemorySize, Helper)(((maxon::OverloadRankMax) nullptr), obj MAXON_MAKE_LIST(PRIVATE_MAXON_DETECT_MEMBER_HELPER3,,,,)))
 
template<typename X >
T & __attribute__ ((always_inline)) void UseVariable(X &&var)
 
enum maxon::VALUEKIND UInt64 MAXON_ENUM_ORDERED_FLAGS (VALUEKIND, "net.maxon.datatype.enum.valuekind", EARLY)
 
enum maxon::COLLECTION_KIND MAXON_ENUM_LIST (COLLECTION_KIND)
 
template<typename T >
decltype(std::declval< T >().CopyFrom(std::declval< const T & >())) TestForCopyFromFunction (OverloadRank1)
 
template<typename T >
std::false_type TestForCopyFromFunction (OverloadRank0)
 
template<typename T , Bool ZEROINITIALIZE = false>
std::enable_if<!std::is_scalar< T >::value, T * >::type PlacementNew (void *ptr)
 
template<typename T , Bool ZEROINITIALIZE, typename... ARGS>
T * PlacementNew (void *ptr, ARGS &&... args)
 
template<typename T , typename ARG >
 __attribute__ ((always_inline)) auto NewCopy(T &dst
 
template<typename T >
 __attribute__ ((always_inline)) ResultOk< T > NewCopy(T &&src)
 
template<typename T >
void Destruct (const T *object)
 
template<typename T >
DestructorPointer GetDestructorPointer ()
 
template<typename T >
void Reset (T &object)
 
template<typename T , typename... ARGS>
static auto Create (ARGS &&... args)
 
enum maxon::SUBSYSTEM MAXON_ENUM_LIST (SUBSYSTEM, "net.maxon.datatype.enum.subsystem")
 
enum maxon::APPLICATION_URLTYPE MAXON_ENUM_LIST (APPLICATION_URLTYPE, "net.maxon.datatype.enum.application_urltype")
 
enum maxon::APPLICATIONMODE MAXON_ENUM_LIST (APPLICATIONMODE, "net.maxon.datatype.enum.applicationmode")
 
enum maxon::APPLICATIONFEATURE MAXON_ENUM_FLAGS (APPLICATIONFEATURE)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataTypePrivateGetDataType (ArrayInterface< T > **, OverloadRank0)
 
template<typename ARRAY >
 MAXON_IMPLEMENTATION_SIMPLE_REGISTER (ArrayImpl< ARRAY >)
 
template<typename T >
const ArrayInterface< T > * ToArrayPtr (const ArrayInterface< T > &array)
 
template<typename T >
WritableArrayInterface< T > * ToWritableArrayPtr (WritableArrayInterface< T > &array)
 
 MAXON_DATATYPE (BackgroundEntryTuple, "net.maxon.datatyoe.backgroundentrytuple", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
enum maxon::BASEARRAYFLAGS MAXON_ENUM_FLAGS (BASEARRAYFLAGS)
 
 MAXON_DATATYPE (BitSet, "net.maxon.datatype.bitset", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<typename T >
T * PrivateInitCopy (void *ptr, const T &src)
 
Int Ctz32 (Int32 x)
 
Int Ctz64 (Int64 x)
 
Int Clz32 (Int32 x)
 
Int Clz64 (Int64 x)
 
template<typename T >
Int Clz (T x)
 
template<typename T >
Int Ctz (T x)
 
template<typename T , Int N>
Block< T > ToBlock (T(&array)[N])
 
template<typename T >
Block< typename maxon::details::BlockType< T >::typeToBlock (T *ptr, Int size)
 
template<typename T >
Block< T > ToSingletonBlock (T &value)
 
template<typename T >
Block< const T > ToSingletonBlock (const T &value)
 
template<typename T >
StridedBlock< typename maxon::details::BlockType< T >::typeToBlock (T *ptr, Int size, Int stride)
 
Block< const CharCharToBlock (const Char *str)
 
Block< const UCharCharToBlock (const UChar *str)
 
template<Int N>
Block< const CharCharToBlock (const Char(&str)[N])
 
template<Int N>
Block< const UCharCharToBlock (const UChar(&str)[N])
 
template<Int N>
Block< const Utf32CharCharToBlock (const Utf32Char(&str)[N])
 
enum maxon::BLOCKARRAYFLAGS MAXON_ENUM_FLAGS (BLOCKARRAYFLAGS)
 
constexpr Bool ConstExprStringsAreEqual (const Char *str1, const Char *str2)
 
enum maxon::BURSTTRIE_SORT MAXON_ENUM_LIST (BURSTTRIE_SORT)
 
enum maxon::BYTEORDER MAXON_ENUM_LIST (BYTEORDER)
 
MAXON_ATTRIBUTE_FORCE_INLINE UInt16 SwapByteOrder (UInt16 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int16 SwapByteOrder (Int16 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE UInt32 SwapByteOrder (UInt32 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int32 SwapByteOrder (Int32 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE UInt64 SwapByteOrder (UInt64 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int64 SwapByteOrder (Int64 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE UInt16 SwapUInt16 (UInt16 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int16 SwapInt16 (Int16 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE UInt32 SwapUInt32 (UInt32 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int32 SwapInt32 (Int32 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE UInt64 SwapUInt64 (UInt64 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int64 SwapInt64 (Int64 data)
 
MAXON_ATTRIBUTE_FORCE_INLINE void SwapUInt16 (UInt16 *addr, Int count=1)
 
MAXON_ATTRIBUTE_FORCE_INLINE void SwapInt16 (Int16 *addr, Int count=1)
 
MAXON_ATTRIBUTE_FORCE_INLINE void SwapUInt32 (UInt32 *addr, Int count=1)
 
MAXON_ATTRIBUTE_FORCE_INLINE void SwapInt32 (Int32 *addr, Int count=1)
 
MAXON_ATTRIBUTE_FORCE_INLINE void SwapUInt64 (UInt64 *addr, Int count=1)
 
MAXON_ATTRIBUTE_FORCE_INLINE void SwapInt64 (Int64 *addr, Int count=1)
 
template<BYTEORDER order>
MAXON_ATTRIBUTE_FORCE_INLINE void ByteOrder_UInt16 (UInt16 *addr, Int count=1)
 
template<BYTEORDER order>
MAXON_ATTRIBUTE_FORCE_INLINE void ByteOrder_Int16 (Int16 *addr, Int count=1)
 
template<BYTEORDER order>
MAXON_ATTRIBUTE_FORCE_INLINE void ByteOrder_UInt32 (UInt32 *addr, Int count=1)
 
template<BYTEORDER order>
MAXON_ATTRIBUTE_FORCE_INLINE void ByteOrder_Int32 (Int32 *addr, Int count=1)
 
template<BYTEORDER order>
MAXON_ATTRIBUTE_FORCE_INLINE void ByteOrder_UInt64 (UInt64 *addr, Int count=1)
 
template<BYTEORDER order>
MAXON_ATTRIBUTE_FORCE_INLINE void ByteOrder_Int64 (Int64 *addr, Int count=1)
 
 MAXON_DATATYPE (BytesValue, "net.maxon.datatype.bytesvalue", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
void ScanParameter (BytesValue &res, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
template<typename C >
Int PrivateGetCount (const C &collection, OverloadRank0)
 
template<typename T , Int N>
Int PrivateGetCount (T(&array)[N], OverloadRank1)
 
template<typename C >
SFINAEHelper< Int, typename C::IsCollection >::type PrivateGetCount (const C &collection, OverloadRank2)
 
template<typename ITERABLE >
Int GetCount (const ITERABLE &iterable)
 
template<typename SET , typename KEY >
MAXON_ATTRIBUTE_FORCE_INLINE Bool PrivateContains (const SET &set, const KEY &key, OverloadRank0)
 
template<typename T , Int N, typename KEY >
Bool PrivateContains (T(&array)[N], const KEY &key, OverloadRank1)
 
template<typename SET , typename KEY >
MAXON_ATTRIBUTE_FORCE_INLINE auto PrivateContains (const SET &set, const KEY &key, OverloadRank1) -> decltype(set.Contains(key))
 
template<typename SET , typename KEY >
MAXON_ATTRIBUTE_FORCE_INLINE SFINAEHelper< Bool, typename SET::IsCollection >::type PrivateContains (const SET &set, const KEY &key, OverloadRank2)
 
template<typename PREDICATE , typename KEY >
MAXON_ATTRIBUTE_FORCE_INLINE Bool Contains (const PREDICATE &predicate, const KEY &key)
 
template<typename COMPARE , typename T1 , typename T2 >
MAXON_ATTRIBUTE_FORCE_INLINE Bool PrivateIsEqual (COMPARE &&cmp, const T1 &a, const T2 &b, OverloadRank0)
 
template<typename COMPARE , typename T1 , typename T2 >
MAXON_ATTRIBUTE_FORCE_INLINE auto PrivateIsEqual (COMPARE &&cmp, const T1 &a, const T2 &b, OverloadRank1) -> decltype(cmp.IsEqual(a, b))
 
template<typename PREDICATE , typename T1 , typename T2 >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsEqual (PREDICATE &&predicate, const T1 &a, const T2 &b)
 
 MAXON_MEMBERTYPE_DETECTOR (IsCollection, IsCollection, std::false_type)
 
enum maxon::COLLECTION_RESIZE_FLAGS MAXON_ENUM_FLAGS (COLLECTION_RESIZE_FLAGS, "net.maxon.datatype.enum.collection_resize_flags", EARLY)
 
template<typename COLLECTION , typename T >
std::conditional<!STD_IS_REPLACEMENT(reference, COLLECTION) &&(GetCollectionKind< COLLECTION >::value !=COLLECTION_KIND::NONE), T &&, T & >::type ValueForward (T &x)
 
template<typename COLLECTION , typename T , Bool STRIDED>
const Block< T, STRIDED, !STD_IS_REPLACEMENT(reference, COLLECTION) &&(GetCollectionKind< COLLECTION >::value !=COLLECTION_KIND::NONE)> & BlockForward (const Block< T, STRIDED > &block)
 
template<typename COLLECTION >
COLLECTION && PrivateGetMap (COLLECTION &&c, OverloadRank0)
 
template<typename COLLECTION >
Substitute< COLLECTION &&, typename std::remove_reference< COLLECTION >::type::MapType >::type PrivateGetMap (COLLECTION &&c, OverloadRank1)
 
enum maxon::CONFIGURATION_CATEGORY MAXON_ENUM_LIST (CONFIGURATION_CATEGORY)
 
enum maxon::CONFIGURATIONENTRY_ORIGIN MAXON_ENUM_LIST (CONFIGURATIONENTRY_ORIGIN)
 
enum maxon::CONFIGURATIONENTRY_STATE MAXON_ENUM_LIST (CONFIGURATIONENTRY_STATE)
 
 MAXON_DATATYPE (ConfigInit, "net.maxon.datatype.configinit", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DEPENDENCY (configuration)
 
Bool QueryConfigBool (const String &symbol)
 
 MAXON_DATATYPE (ConstData, "net.maxon.datatype.constdata", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<GET_DATATYPE_POLICY POLICY, typename... T>
ResultOk< const ContainerDataType< T... > & > PrivateGetDataType (ContainerInterface< T... > **, OverloadRank1)
 
template<GET_DATATYPE_POLICY POLICY, Int DEPTH>
Result< DataTypePrivateGetDataType (RecursiveContainer< DEPTH > **, OverloadRank0)
 
 MAXON_DEPENDENCY (cpuidinit)
 
template<typename T1 , typename T2 >
MAXON_ATTRIBUTE_FORCE_INLINE bool operator== (const CustomSTLAllocator< T1 > &, const CustomSTLAllocator< T2 > &) noexcept
 
template<typename T1 , typename T2 >
MAXON_ATTRIBUTE_FORCE_INLINE bool operator!= (const CustomSTLAllocator< T1 > &, const CustomSTLAllocator< T2 > &) noexcept
 
 MAXON_REGISTRY (DataType, LegacyDataTypeIdentifiers, "net.maxon.registry.datatype.legacyidentifiers")
 
 MAXON_DATATYPE (LanguageStringDataDescription, "net.maxon.datatype.languagestringdatadescription", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DATATYPE (VariadicIdsElement, "net.maxon.datatype.variadicidselement", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<typename T >
Result< void > AddResourceDefault (DataDictionary &props, const T &t, OverloadRank0)
 
template<typename T >
SFINAEHelper< Result< void >, typename T::HasDefault >::type AddResourceDefault (DataDictionary &props, const T &t, OverloadRank1)
 
template<typename TYPE >
Result< BaseArray< Tuple< Id, Data > > > BlockToEnumArray (const Block< TYPE > &enumBlock)
 
template<typename T >
Result< void > AddResourceProperty (DataDescription &description, const T &t, const Delegate< Result< void >(DataDictionary &props)> &addProps=nullptr)
 
template<typename T >
Result< void > EraseResourceProperty (DataDescription &description, const T &t)
 
enum maxon::CONDITIONTOKENTYPE MAXON_ENUM_LIST (CONDITIONTOKENTYPE)
 
 MAXON_DATATYPE (ProcessEnumListDelegate, "net.maxon.datatype.processenumlistdelegate", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_REGISTRY (ProcessEnumListDelegate, ProcessEnumListDelegates, "net.maxon.datadescription.registry.processenumlist")
 
 MAXON_DATATYPE (EnumVariableResolveDelegate, "net.maxon.datatype.delegate.enumvariableresolve", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_REGISTRY (EnumVariableResolveDelegate, EnumVariableResolveDelegates, "net.maxon.datadescription.registry.enumvariableresolve")
 
Bool UseFilterData (const Data *filterData, const Data &compare)
 
enum maxon::GETDATAFLAGS MAXON_ENUM_FLAGS (GETDATAFLAGS)
 
 MAXON_DECLARATION (Class< DataDescriptionDefinition >, DataDescriptionDefinitionClass, "net.maxon.class.datadescriptiondefinition", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DATATYPE (LanguageStringDataDescriptionDefinition, "net.maxon.datatype.languagestringdatadescriptiondefinition", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
enum maxon::DBVERSION MAXON_ENUM_ORDERED_LIST (DBVERSION)
 
enum maxon::DESCRIPTIONMESSAGECHECKFLAGS MAXON_ENUM_FLAGS (DESCRIPTIONMESSAGECHECKFLAGS)
 
 MAXON_DATATYPE (DescriptionMessageCall, "net.maxon.datatype.descriptionmessagecall", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
enum maxon::LOADDESCRIPTIONMODE MAXON_ENUM_LIST (LOADDESCRIPTIONMODE)
 
 MAXON_DECLARATION (Class< DataDescriptionObjectRef >, DataDescriptionObjectClass, "net.maxon.class.datadescriptionobject", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
Result< void > MergeDataDictionaries (DataDictionary &base, const DataDictionary &other, Bool mergeSubContainers)
 
Result< void > MergeDataDictionariesPreferBase (DataDictionary &base, const DataDictionary &other, Bool mergeSubContainers)
 
Result< DataPrivateGetDataDescriptionValue (const Id &databaseScope, const InternedId &attributeData, const ConstDataPtr &keyPtr)
 
template<typename ATTRIBUTETYPE , typename KEY >
static Result< typename IsFidClass< ATTRIBUTETYPE >::typeGetDataDescriptionValue (ATTRIBUTETYPE &&attribute, KEY &&key)
 
template<typename TT , typename ATTRIBUTETYPE >
static Opt< TT > GetDataDescriptionValue2 (ATTRIBUTETYPE &&attribute, const ConstDataPtr &key)
 
template<typename ATTRIBUTETYPE , typename KEY >
static Result< typename IsFidClass< KEY >::typeGetDataDescriptionValueFromKey (ATTRIBUTETYPE &&attribute, KEY &&key)
 
template<typename TT , typename KEY >
TT GetDefaultFromFidIfAvailable (KEY &&key, OverloadRank0)
 
template<typename TT , typename KEY >
SFINAEHelper< TT, decltype(std::remove_reference< KEY >::type::DEFAULTVALUE)>::type GetDefaultFromFidIfAvailable (KEY &&key, OverloadRank2)
 
ConstDataPtr GetDefaultValueKey ()
 
template<typename SRCCLASS , typename PROPSRCTYPE , typename DSTCLASS , typename PROPDSTTYPE >
Result< void > TransferPropertyIfAvailable (const SRCCLASS &src, PROPSRCTYPE &&srcType, DSTCLASS &dst, PROPDSTTYPE &&dstType)
 
 MAXON_DECLARATION (Class< DataDictionaryObjectRef >, DataDictionaryObjectEmptyClass, "net.maxon.class.datadictionaryobjectempty", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (Class< DataDictionaryObjectRef >, DataDictionaryObjectClass, "net.maxon.class.datadictionaryobject", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (Class< DataDictionaryObjectRef >, DataDictionaryBlockArraySmallObjectClass, "net.maxon.class.datadictionaryblockarraysmallobject", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (Class< DataDictionaryObjectRef >, DataDictionaryObjectLockedClass, "net.maxon.class.datadictionaryobjectlocked", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (Class< DataDictionaryObjectRef >, DataDictionaryObjectSyncedClass, "net.maxon.class.datadictionaryobjectsynced", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (Class< DataDictionaryReferenceObjectRef >, DataDictionaryObjectReferenceClass, "net.maxon.class.datadictionaryobjectreference", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
Result< DataDictionaryObjectRef > CreateDataDictionaryReferenceObject (DataDictionary *reference)
 
Result< DataDictionaryObjectRef > CreateDataDictionaryReferenceObject (const DataDictionary *reference)
 
Result< DataDictionary > GetDataDictionaryFromDataDictionaryObjectRef (const DataDictionaryObjectRef &ref)
 
 MAXON_REGISTRY (DataFormatReaderFactory, DataFormatReaderFactories, "net.maxon.registry.dataformatreaderfactories")
 
 MAXON_REGISTRY (DataFormatWriterFactory, DataFormatWriterFactories, "net.maxon.registry.dataformatwriterfactories")
 
 MAXON_DECLARATION (Class< DataFormatWriterRef >, DataFormatWriterBinaryClass, "net.maxon.class.dataformatwriterbinary", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (Class< DataFormatWriterRef >, DataFormatWriterJsonClass, "net.maxon.class.dataformatwriterjson", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (Class< DataFormatWriterRef >, DataFormatWriterXmlClass, "net.maxon.class.dataformatwriterxml", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (Class< DataFormatReaderRef >, DataFormatReaderBinaryClass, "net.maxon.class.dataformatreaderbinary", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (Class< DataFormatReaderRef >, DataFormatReaderJsonClass, "net.maxon.class.dataformatreaderjson", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (Class< DataFormatReaderRef >, DataFormatReaderXmlClass, "net.maxon.class.dataformatreaderxml", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DATATYPE (IDENT_VOID, "net.maxon.ident_void", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<typename T >
ResultPtr< void > CreateHelper ()
 
template<typename T >
void DeleteHelper (void *helper)
 
template<typename MAINCLASS , typename HELPERCLASS >
Result< void > ReadHelper (DataSerializeInterface *ds, void *classPtr, void *helperPtr, UInt elementHash)
 
template<typename MAINCLASS , typename HELPERCLASS >
Result< void > WriteHelper (DataSerializeInterface *ds, void *classPtr, void *helperPtr, UInt elementHash)
 
template<typename T >
void ArrayConversionHelper (void *arrayPtr, Char *memBuffer)
 
template<typename T >
void SetConversionHelper (void *mapPtr, Char *memBuffer)
 
template<typename T >
void MapConversionHelper (void *mapPtr, Char *memBuffer)
 
DESCRIBEFLAGS operator| (DESCRIBEFLAGS a, DESCRIBEFLAGS b)
 
DESCRIBEFLAGS operator& (DESCRIBEFLAGS a, DESCRIBEFLAGS b)
 
DESCRIBEFLAGS operator~ (DESCRIBEFLAGS a)
 
DESCRIBEFLAGSoperator&= (DESCRIBEFLAGS &a, DESCRIBEFLAGS b)
 
enum maxon::PREPAREHELPERFLAGS MAXON_ENUM_FLAGS (PREPAREHELPERFLAGS)
 
 MAXON_DECLARATION (Class< DataSerializeRef >, DataSerializeBaseClass, "net.maxon.class.dataserializebase", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (Class< DataSerializeReaderRef >, DataSerializeReaderClass, "net.maxon.class.dataserializereader", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (Class< DataSerializeWriterRef >, DataSerializeWriterClass, "net.maxon.class.dataserializewriter", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType & > PrivateGetDataType (GenericArithmetic **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType & > PrivateGetDataType (void **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType & > PrivateGetDataType (std::nullptr_t **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType & > PrivateGetDataType (InvalidType **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
SFINAEHelper< Result< const DataType & >, typename T::NonvirtualInterfaceMarker >::type PrivateGetDataType (T **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
SFINAEHelper< Result< const DataType & >, typename T::InterfaceMarker >::type PrivateGetDataType (T **, OverloadRank1)
 
template<GET_DATATYPE_POLICY POLICY>
Result< const DataType & > PrivateGetDataType (void *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType & > PrivateGetDataType (DataType **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType & > PrivateGetDataType (DataType::Primary **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType & > PrivateGetDataType (TupleDataType **, OverloadRank0)
 
template<typename T >
void PrivateDataTypeMarker (T *)
 
 MAXON_REGISTRY (DataType, DataTypes, "net.maxon.registry.datatypes")
 
void * PrivateDataTypeMarker (Char *)
 
 MAXON_DECLARATION (maxon::DataType, DT_Char, "char", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (Char **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (Char)
 
void * PrivateDataTypeMarker (UChar *)
 
 MAXON_DECLARATION (maxon::DataType, DT_UChar, "uchar", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (UChar **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (UChar)
 
void * PrivateDataTypeMarker (Int16 *)
 
 MAXON_DECLARATION (maxon::DataType, DT_Int16, "int16", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (Int16 **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (Int16)
 
void * PrivateDataTypeMarker (UInt16 *)
 
 MAXON_DECLARATION (maxon::DataType, DT_UInt16, "uint16", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (UInt16 **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (UInt16)
 
void * PrivateDataTypeMarker (Int32 *)
 
 MAXON_DECLARATION (maxon::DataType, DT_Int32, "int32", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (Int32 **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (Int32)
 
void * PrivateDataTypeMarker (UInt32 *)
 
 MAXON_DECLARATION (maxon::DataType, DT_UInt32, "uint32", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (UInt32 **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (UInt32)
 
void * PrivateDataTypeMarker (Int64 *)
 
 MAXON_DECLARATION (maxon::DataType, DT_Int64, "int64", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (Int64 **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (Int64)
 
void * PrivateDataTypeMarker (UInt64 *)
 
 MAXON_DECLARATION (maxon::DataType, DT_UInt64, "uint64", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (UInt64 **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (UInt64)
 
void * PrivateDataTypeMarker (Utf16Char *)
 
 MAXON_DECLARATION (maxon::DataType, DT_Utf16Char, "utf16char", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (Utf16Char **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (Utf16Char)
 
void * PrivateDataTypeMarker (Utf32Char *)
 
 MAXON_DECLARATION (maxon::DataType, DT_Utf32Char, "utf32char", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (Utf32Char **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (Utf32Char)
 
void * PrivateDataTypeMarker (Float32 *)
 
 MAXON_DECLARATION (maxon::DataType, DT_Float32, "float32", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (Float32 **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (Float32)
 
void * PrivateDataTypeMarker (Float64 *)
 
 MAXON_DECLARATION (maxon::DataType, DT_Float64, "float64", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (Float64 **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (Float64)
 
void * PrivateDataTypeMarker (Bool *)
 
 MAXON_DECLARATION (maxon::DataType, DT_Bool, "bool", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (Bool **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (Bool)
 
void * PrivateDataTypeMarker (Byte *)
 
 MAXON_DECLARATION (maxon::DataType, DT_Byte, "byte", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (Byte **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (Byte)
 
void * PrivateDataTypeMarker (AInt *)
 
 MAXON_DECLARATION (maxon::DataType, DT_AInt, "int", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (AInt **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (AInt)
 
void * PrivateDataTypeMarker (AUInt *)
 
 MAXON_DECLARATION (maxon::DataType, DT_AUInt, "uint", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (AUInt **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (AUInt)
 
void * PrivateDataTypeMarker (AFloat *)
 
 MAXON_DECLARATION (maxon::DataType, DT_AFloat, "float", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (AFloat **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (AFloat)
 
void * PrivateDataTypeMarker (UniqueHash *)
 
 MAXON_DECLARATION (maxon::DataType, DT_UniqueHash, "net.maxon.datatype.hash", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (UniqueHash **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (UniqueHash)
 
void * PrivateDataTypeMarker (Id *)
 
 MAXON_DECLARATION (maxon::DataType, DT_Id, "net.maxon.datatype.id", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (Id **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (Id)
 
void * PrivateDataTypeMarker (LiteralId *)
 
 MAXON_DECLARATION (maxon::DataType, DT_LiteralId, "net.maxon.datatype.literalid", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (LiteralId **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (LiteralId)
 
void * PrivateDataTypeMarker (InternedId *)
 
 MAXON_DECLARATION (maxon::DataType, DT_InternedId, "net.maxon.datatype.internedid", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (InternedId **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (InternedId)
 
void * PrivateDataTypeMarker (Data *)
 
 MAXON_DECLARATION (maxon::DataType, DT_Data, "net.maxon.datatype.data", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (Data **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (Data)
 
void * PrivateDataTypeMarker (UnitType *)
 
 MAXON_DECLARATION (maxon::DataType, DT_UnitType, "net.maxon.datatype.unittype", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (UnitType **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (UnitType)
 
void * PrivateDataTypeMarker (SourceLocation *)
 
 MAXON_DECLARATION (maxon::DataType, DT_SourceLocation, "net.maxon.datatype.sourcelocation", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (SourceLocation **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (SourceLocation)
 
void * PrivateDataTypeMarker (DelegateBase *)
 
 MAXON_DECLARATION (maxon::DataType, DT_DelegateBase, "net.maxon.datatype.delegatebase", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (DelegateBase **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (DelegateBase)
 
template<Bool , typename T >
ResultOk< const DataType & > PrivateGetEnumDataType (T *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
std::enable_if< STD_IS_REPLACEMENT(enum, T), ResultOk< const DataType & > >::type PrivateGetDataType (T **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType & > PrivateGetDataType (long **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType & > PrivateGetDataType (unsigned long **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType & > PrivateGetDataType (ParametricType **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType & > PrivateGetDataType (ComponentDescriptor **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
std::enable_if< GetDirectlyReferencedType< T >::value, Result< DataType > >::type PrivateGetDataType (T **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataTypePrivateGetDataType (T ***, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataTypePrivateGetDataType (Block< T > **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataTypePrivateGetDataType (StridedBlock< T > **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
SFINAEHelper< Result< DataType >, typename T::VectorStrideType >::type PrivateGetDataType (T **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataTypePrivateGetDataType (Opt< T > **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataTypePrivateGetDataType (Result< T > **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY>
Result< DataTypePrivateGetDataType (AtomicBool **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataTypePrivateGetDataType (Atomic8< T > **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataTypePrivateGetDataType (Atomic16< T > **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataTypePrivateGetDataType (Atomic32< T > **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataTypePrivateGetDataType (Atomic64< T > **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataTypePrivateGetDataType (AtomicPtr< T > **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataTypePrivateGetDataType (AtomicFloatType< T > **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataTypePrivateGetDataType (BaseArray< T > **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename... T>
Result< TupleDataTypePrivateGetDataType (Tuple< T... > **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T , typename = typename T::StructTupleType>
Result< TupleDataTypePrivateGetDataType (T **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename R , typename... ARGS>
Result< DelegateDataTypePrivateGetDataType (Delegate< R(ARGS...)> **, OverloadRank2)
 
template<typename T , GET_DATATYPE_POLICY POLICY>
const auto & GetDataType ()
 
template<GET_DATATYPE_POLICY POLICY>
ResultOk< const DataType & > PrivateGetDataType (Generic **, OverloadRank0)
 
void * PrivateDataTypeMarker (ConstDataPtr *)
 
 MAXON_DECLARATION (maxon::DataType, DT_ConstDataPtr, "net.maxon.datatype.constdataptr", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (ConstDataPtr **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (ConstDataPtr)
 
void * PrivateDataTypeMarker (TrivialDataPtr *)
 
 MAXON_DECLARATION (maxon::DataType, DT_TrivialDataPtr, "net.maxon.datatype.trivialdataptr", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (TrivialDataPtr **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (TrivialDataPtr)
 
void * PrivateDataTypeMarker (DataPtr *)
 
 MAXON_DECLARATION (maxon::DataType, DT_DataPtr, "net.maxon.datatype.dataptr", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (DataPtr **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (DataPtr)
 
void * PrivateDataTypeMarker (MoveDataPtr *)
 
 MAXON_DECLARATION (maxon::DataType, DT_MoveDataPtr, "net.maxon.datatype.movedataptr", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (MoveDataPtr **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (MoveDataPtr)
 
void * PrivateDataTypeMarker (ForwardingDataPtr *)
 
 MAXON_DECLARATION (maxon::DataType, DT_ForwardingDataPtr, "net.maxon.datatype.forwardingdataptr", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (ForwardingDataPtr **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (ForwardingDataPtr)
 
void * PrivateDataTypeMarker (Member *)
 
 MAXON_DECLARATION (maxon::DataType, DT_Member, "net.maxon.datatype.member", static constexpr maxon::EntityBase::TYPE TYPE=maxon::EntityBase::TYPE::DATATYPE;MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<maxon::GET_DATATYPE_POLICY >
maxon::ResultOk< const maxon::DataType & > PrivateGetDataType (Member **, maxon::OverloadRank2)
 
 MAXON_ASSERT_LEGAL_LAYOUT (Member)
 
template<GET_DATATYPE_POLICY POLICY, typename... T>
Result< TupleDataTypePrivateGetDataType (NamedTuple< T... > **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename T , T C>
Result< DataTypePrivateGetDataType (std::integral_constant< T, C > **, OverloadRank0)
 
 MAXON_DATATYPE_EARLY_ENUM (WRITEMETA, "net.maxon.datatype.enum.writemeta")
 
 MAXON_DATATYPE_EARLY_ENUM (TARGETAUDIENCE, "net.maxon.datatype.enum.targetaudience")
 
 MAXON_DATATYPE_EARLY_ENUM (OUTPUT, "net.maxon.datatype.enum.output")
 
 MAXON_DATATYPE_EARLY_ENUM (VALUEKIND, "net.maxon.datatype.enum.valuekind")
 
 MAXON_DATATYPE_EARLY_ENUM (COMPARERESULT, "net.maxon.datatype.enum.compareresult")
 
 MAXON_DATATYPE_EARLY_ENUM (EQUALITY, "net.maxon.datatype.enum.equality")
 
 MAXON_DATATYPE_EARLY_ENUM (COLLECTION_RESIZE_FLAGS, "net.maxon.datatype.enum.collection_resize_flags")
 
enum maxon::DATATYPEBUILDERNAME MAXON_ENUM_LIST (DATATYPEBUILDERNAME)
 
 MAXON_DATATYPE (DataTypeBuilderEntry, "net.maxon.datatype.datatypebuilderentry", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_REGISTRY (DataTypeBuilderEntry, DataTypeBuilderRegistry, "net.maxon.registry.datatypebuilderregistry")
 
enum maxon::CONVERSION_FLAGS MAXON_ENUM_FLAGS (CONVERSION_FLAGS)
 
enum maxon::GET_DATATYPE_POLICY MAXON_ENUM_FLAGS (GET_DATATYPE_POLICY)
 
Bool operator== (const ForwardingDataPtr &a, const Data &b)
 
Bool operator!= (const ForwardingDataPtr &a, const Data &b)
 
 MAXON_DETECT_MEMBER_HELPER (DescribeIO, const DataSerializeInterface &)
 
template<typename T >
Result< void > DescribeIO (const T &s, const DataSerializeInterface &dsi)
 
enum maxon::DATATYPEMODE MAXON_ENUM_LIST (DATATYPEMODE)
 
Result< void * > DecltypeNewInstanceHelper (const void *)
 
template<typename T >
static Result< void * > PrivateNewInterfaceInstance (OverloadRank0)
 
template<typename T >
static decltype(DecltypeNewInstanceHelper(T::Alloc(maxon::SourceLocation()))) MAXON_WARN_UNUSED PrivateNewInterfaceInstance (OverloadRank1)
 
enum maxon::INNERMOST_MEMBER Int32 MAXON_ENUM_ORDERED_LIST (INNERMOST_MEMBER)
 
enum maxon::DAYOFWEEK MAXON_ENUM_LIST (DAYOFWEEK)
 
enum maxon::DST Int16 MAXON_ENUM_LIST (DST)
 
enum maxon::JULIANDATE MAXON_ENUM_LIST (JULIANDATE)
 
 MAXON_DATATYPE (UniversalDateTime, "net.maxon.datatype.universaldatetime", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DATATYPE (LocalDateTime, "net.maxon.datatype.localdatetime", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
void ScanParameter (UniversalDateTime &res, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
enum maxon::HARDWAREBREAKPOINTTYPE MAXON_ENUM_LIST (HARDWAREBREAKPOINTTYPE)
 
enum maxon::HARDWAREBREAKPOINTSIZE MAXON_ENUM_LIST (HARDWAREBREAKPOINTSIZE)
 
Int sprintf_safe (Char *_DstBuf, Int _MaxCount, const Char *_Format,...)
 
 MAXON_DECLARATION (ComponentDescriptor, EagerDecoratorComponent, "net.maxon.component.eagerdecorator", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (ComponentDescriptor, WeakDecoratorComponent, "net.maxon.component.weakdecorator", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr< T > _ReallocMem (T *p, Int cnt, MAXON_SOURCE_LOCATION_DECLARATION)
 
template<typename T >
void DeleteMem (T *&p)
 
void DeleteConstPtrMem (const void *p)
 
MAXON_ATTRIBUTE_FORCE_INLINE void MemCopy (void *dst, const void *src, Int size)
 
MAXON_ATTRIBUTE_FORCE_INLINE void MemMove (void *dst, const void *src, Int size)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE void MemCopyType (T *dst, const T *src, Int cnt)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE void MemMoveType (T *dst, const T *src, Int cnt)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ClearMem (void *mem, Int size, UChar value=0)
 
MAXON_ATTRIBUTE_FORCE_INLINE void SecureClearMem (volatile void *mem, Int size, UChar value=0)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int CompareMem (const void *block1, const void *block2, Int size)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE void ClearMemType (T *data_ptr, Int cnt, UChar value=0)
 
 MAXON_MEMBERTYPE_DETECTOR (IsArrayAllocator, IsArrayAllocator, std::false_type)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE const T & PrivateConstRefDefaultValue (T *, OverloadRank0)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE const T & PrivateConstRefDefaultValueHelper (OverloadRank0)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE DefaultValueDetector< const T &, &T::DefaultValue >::type PrivateConstRefDefaultValueHelper (OverloadRank1)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE DefaultValueDetector< const T &, &T::DefaultValueRef >::type PrivateConstRefDefaultValueHelper (OverloadRank2)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINEPrivateDefaultValueHelper (OverloadRank0)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE DefaultValueDetector< T, &T::DefaultValue >::type PrivateDefaultValueHelper (OverloadRank1)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE DefaultValueDetector< const T &, &T::DefaultValue >::type PrivateDefaultValueHelper (OverloadRank1)
 
template<typename T , Bool ALLOW_NONCONST>
MAXON_ATTRIBUTE_FORCE_INLINEPrivateDefaultValueDispatcher (OverloadRank0)
 
template<typename T , Bool ALLOW_NONCONST>
MAXON_ATTRIBUTE_FORCE_INLINE SFINAEHelper< T, typename DefaultValueFunctions< typename std::decay< T >::type >::Default >::type PrivateDefaultValueDispatcher (OverloadRank1)
 
template<typename T , Bool ALLOW_NONCONST>
MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if< IsZeroInitialized< typename std::decay< T >::type >::value||STD_IS_REPLACEMENT(same, typename std::decay< T >::type, Generic), T >::type PrivateDefaultValueDispatcher (OverloadRank2)
 
template<typename T , Bool ALLOW_NONCONST>
MAXON_ATTRIBUTE_FORCE_INLINEDefaultValue ()
 
template<>
MAXON_ATTRIBUTE_FORCE_INLINE void DefaultValue< void, false > ()
 
enum maxon::NULL_RETURN_REASON MAXON_ENUM_LIST (NULL_RETURN_REASON)
 
ThreadReferencedError PrivateGetNullReturnError (NULL_RETURN_REASON reason)
 
MAXON_ATTRIBUTE_FORCE_INLINE void PrivateLogNullptrError ()
 
MAXON_ATTRIBUTE_FORCE_INLINE Bool PrivateLogNullptrError (Bool result)
 
template<typename T , Bool ALLOW_CONST>
MAXON_ATTRIBUTE_FORCE_INLINEPrivateDefaultReturnValue (NULL_RETURN_REASON reason, OverloadRank0)
 
template<typename T , Bool ALLOW_CONST>
MAXON_ATTRIBUTE_FORCE_INLINE SFINAEHelper< T, typename DefaultValueFunctions< typename std::decay< T >::type >::Default >::type PrivateDefaultReturnValue (NULL_RETURN_REASON reason, OverloadRank1)
 
template<typename T , Bool ALLOW_CONST>
MAXON_ATTRIBUTE_FORCE_INLINE SFINAEHelper< T, typename DefaultValueFunctions< typename std::decay< T >::type >::ResultMarker >::type PrivateDefaultReturnValue (NULL_RETURN_REASON reason, OverloadRank2)
 
template<typename T , Bool ALLOW_CONST>
MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if< STD_IS_REPLACEMENT(same, Id, typename std::decay< T >::type), T >::type PrivateDefaultReturnValue (NULL_RETURN_REASON reason, OverloadRank3)
 
template<typename T , Bool ALLOW_CONST>
MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if< IsZeroInitialized< typename std::decay< T >::type >::value||STD_IS_REPLACEMENT(same, typename std::decay< T >::type, Generic), T >::type PrivateDefaultReturnValue (NULL_RETURN_REASON reason, OverloadRank4)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINEPrivateIncompleteNullReturnValue (NULL_RETURN_REASON reason, OverloadRank0)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE SFINAEHelper< T, typename DefaultValueFunctions< typename std::decay< T >::type >::Default >::type PrivateIncompleteNullReturnValue (NULL_RETURN_REASON reason, OverloadRank1)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE SFINAEHelper< T, typename DefaultValueFunctions< typename std::decay< T >::type >::ResultMarker >::type PrivateIncompleteNullReturnValue (NULL_RETURN_REASON reason, OverloadRank2)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if< STD_IS_REPLACEMENT(same, Id, typename std::decay< T >::type), T >::type PrivateIncompleteNullReturnValue (NULL_RETURN_REASON reason, OverloadRank3)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if< IsZeroInitialized< typename std::decay< T >::type >::value, T >::type PrivateIncompleteNullReturnValue (NULL_RETURN_REASON reason, OverloadRank4)
 
void operator% (const Result< Bool > &res, Result< Bool > &yieldResult)
 
void operator% (const Result< void > &res, Result< Bool > &yieldResult)
 
 MAXON_REGISTRY (DescriptionProcessor, DescriptionProcessors, "net.maxon.registry.descriptionprocessors")
 
 MAXON_DECLARATION (Class< Error >, ErrorObjectClass, "net.maxon.class.errorobject", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (AggregatedError, AggregatedErrorObject, "net.maxon.object.aggregatederror", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
MAXON_ATTRIBUTE_FORCE_INLINE void operator% (ErrorPtr &rv, ThreadReferencedError &err)
 
template<typename R >
Cast (ErrorPtr &ref)
 
template<typename ERRORTYPE >
Bool IsErrorOfType (const Error &err)
 
 MAXON_REGISTRY (JobRef, ExecutionJobs, "net.maxon.registry.executionjobs")
 
template<typename HELPER >
const AttributeInternedId g_attributeInternedId (HELPER::GetId().GetCString())
 
 MAXON_MEMBERTYPE_DETECTOR (IsFidClass, FidType, std::false_type)
 
template<typename RESTRICT , Bool ONLYFID, typename KEY >
std::enable_if<!IsFidClass< KEY >::value, typename std::conditional< STD_IS_REPLACEMENT(reference, KEY)||STD_IS_REPLACEMENT(const, KEY), ConstDataPtr, MoveDataPtr >::type >::type ConvertKeyToDataPtr (KEY &&key)
 
template<typename RESTRICT , Bool ONLYFID, typename KEY >
std::enable_if< IsFidClass< KEY >::value, ConstDataPtr >::type ConvertKeyToDataPtr (KEY &&key)
 
template<typename T >
RESTRICT TestRestriction (T y, OverloadRank0)
 
 MAXON_MEMBERTYPE_DETECTOR (GetRestrict, RESTRICT_DICTIONARY_PROPS, maxon::RESTRICT)
 
Bool IsSourceControlAvailable ()
 
enum maxon::FILEFORMATDETECTIONFLAGS MAXON_ENUM_FLAGS (FILEFORMATDETECTIONFLAGS)
 
 MAXON_REGISTRY (FileFormat, FileFormats, "net.maxon.registry.fileformats")
 
 MAXON_DECLARATION (Class< FileFormat >, FileFormatBaseClass, "net.maxon.class.fileformatbase", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (Class< FileFormatDetectionCacheRef >, FileFormatDetectionCacheClass, "net.maxon.class.fileformatdetectioncache", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
enum maxon::FILEFORMAT_PRIORITY MAXON_ENUM_LIST (FILEFORMAT_PRIORITY)
 
FILEFORMAT_PRIORITY operator+ (FILEFORMAT_PRIORITY s1, FILEFORMAT_PRIORITY s2)
 
FILEFORMAT_PRIORITY operator- (FILEFORMAT_PRIORITY s1, FILEFORMAT_PRIORITY s2)
 
 MAXON_REGISTRY (FileFormatHandler, FileFormatHandlers, "net.maxon.registry.fileformathandlers")
 
 MAXON_MEMBERTYPE_DETECTOR (GetNonConstIteratorType, Iterator, std::false_type)
 
 MAXON_MEMBERTYPE_DETECTOR (GetConstIteratorType, ConstIterator, std::false_type)
 
 MAXON_MEMBERTYPE_DETECTOR (GetCollectionType, CollectionType, T)
 
 MAXON_MEMBERTYPE_DETECTOR (IsForEachIterator, IsForEachIterator, std::false_type)
 
template<typename I >
ReverseIterator< typename GetIteratorType< typename std::remove_reference< I >::type >::typeRBegin (I &&iterable)
 
template<typename I >
ReverseIterator< typename GetIteratorType< typename std::remove_reference< I >::type >::typeREnd (I &&iterable)
 
template<typename COLLECTION >
MAXON_ATTRIBUTE_FORCE_INLINE auto begin (COLLECTION &&c) -> decltype(c.Begin())
 
template<typename COLLECTION >
MAXON_ATTRIBUTE_FORCE_INLINE auto end (COLLECTION &&c) -> decltype(c.End())
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataTypePrivateGetDataType (ForwardRef< T > **, OverloadRank0)
 
Bool CompareFloat (Float32 a, Float32 b, Float32 epsilon=1e-10f)
 
Bool CompareFloat (Float64 a, Float64 b, Float64 epsilon=1e-10)
 
Bool CompareFloatTolerant (Float32 a, Float32 b)
 
Bool CompareFloatTolerant (Float64 a, Float64 b)
 
Bool CheckFloat (Float32 r)
 
Bool CheckFloat (Float64 r)
 
Float32 RepairFloat (Float32 r)
 
Float64 RepairFloat (Float64 r)
 
Float32 BoxStep (Float32 lowerLimit, Float32 upperLimit, Float32 x)
 
Float64 BoxStep (Float64 lowerLimit, Float64 upperLimit, Float64 x)
 
Float32 SmoothStep (Float32 lowerLimit, Float32 upperLimit, Float32 x)
 
Float64 SmoothStep (Float64 lowerLimit, Float64 upperLimit, Float64 x)
 
Float32 Modulo (Float32 a, Float32 b)
 
Float64 Modulo (Float64 a, Float64 b)
 
Int32 Modulo (Int32 a, Int32 b)
 
Int64 Modulo (Int64 a, Int64 b)
 
Float32 Bias (Float32 b, Float32 x)
 
Float64 Bias (Float64 b, Float64 x)
 
Float32 Truncate (Float32 x)
 
Float64 Truncate (Float64 x)
 
 MAXON_DATATYPE (HalfFloat, "float16", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
enum maxon::HASHMAP_ENTRY_LAYOUT MAXON_ENUM_LIST (HASHMAP_ENTRY_LAYOUT)
 
enum maxon::HASHMAP_MODE MAXON_ENUM_LIST (HASHMAP_MODE)
 
 MAXON_DECLARATION (Class< HierarchyObjectRef<>>, HierarchyObjectClass, "net.maxon.class.hierarchyobject", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<typename REFTYPE >
static Result< BoolTraverseChildren (const REFTYPE &object, const Delegate< Result< Bool >(const REFTYPE &object, const REFTYPE &parent, const ConstDataPtr &branchId, Int depth)> &function, const ConstDataPtr &branchId=ConstDataPtr(), Int depth=Int(0))
 
template<typename REFTYPE >
static Result< BoolTraverseMeAndChildren (const REFTYPE &object, const Delegate< Result< Bool >(const REFTYPE &object, const REFTYPE &parent, const ConstDataPtr &branchId, Int depth)> &function, const ConstDataPtr &branchId=ConstDataPtr(), Int depth=Int(0))
 
template<typename REFTYPE >
static Result< BoolTraverseChildren (const REFTYPE &t, const ConstDataPtr &branch, const Delegate< Result< Bool >(const REFTYPE &child, const REFTYPE &parent, const ConstDataPtr &branch, Int depth)> &func, Int depth)
 
template<typename REFTYPE >
static Result< BoolTraverseMeAndChildren (const REFTYPE &t, const REFTYPE &parent, const ConstDataPtr &branch, const Delegate< Result< Bool >(const REFTYPE &child, const REFTYPE &parent, const ConstDataPtr &branch, Int depth)> &func, Int depth=0)
 
enum maxon::ASSET_UPDATE_POLICY MAXON_ENUM_LIST (ASSET_UPDATE_POLICY, "net.maxon.datatype.enum.asset_update_policy")
 
Bool LessThan (UInt a1, UInt a2, UInt b1, UInt b2)
 
template<typename C >
DefaultValueDetector< C *, &C::DefaultValue >::type ImplementationCreateDefaultValue (OverloadRank3)
 
template<typename C >
std::enable_if< MAXON_IS_COW_KIND(C::PrivateInterface::Hxx1::ReferenceClass::Handler::KIND), C * >::type ImplementationCreateDefaultValue (OverloadRank2)
 
template<typename C >
SFINAEHelper< C *, typename C::PrivateInterface::Hxx1::ReferenceClass::Handler >::type ImplementationCreateDefaultValue (OverloadRank1)
 
template<typename C >
C * ImplementationCreateDefaultValue (OverloadRank0)
 
template<typename C >
DefaultValueDetector< C *, &C::DefaultValue >::type ImplementationDestroyDefaultValue (const C *, OverloadRank3)
 
template<typename C >
std::enable_if< MAXON_IS_COW_KIND(C::PrivateInterface::Hxx1::ReferenceClass::Handler::KIND), C * >::type ImplementationDestroyDefaultValue (const C *o, OverloadRank2)
 
template<typename C >
void ImplementationDestroyDefaultValue (const C *, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename... T>
Result< DataTypePrivateGetDataType (IntersectionType< T... > **, OverloadRank0)
 
template<GET_DATATYPE_POLICY POLICY, typename... T>
Result< DataTypePrivateGetDataType (UnionType< T... > **, OverloadRank0)
 
enum maxon::IOARCHIVESTOREMETHOD MAXON_ENUM_LIST (IOARCHIVESTOREMETHOD)
 
enum maxon::IOARCHIVEEXTRACTFLAGS MAXON_ENUM_FLAGS (IOARCHIVEEXTRACTFLAGS)
 
 MAXON_REGISTRY (Class< ReadArchiveRef >, ReadArchiveClasses, "net.maxon.registry.readarchiveclasses")
 
 MAXON_REGISTRY (Class< WriteArchiveRef >, WriteArchiveClasses, "net.maxon.registry.writearchiveclasses")
 
enum maxon::IOBROWSEFLAGS MAXON_ENUM_FLAGS (IOBROWSEFLAGS, "net.maxon.datatype.enum.iobrowseflags")
 
 MAXON_DECLARATION (Class< IoBrowseRef >, IoBrowseBaseClass, "net.maxon.class.iobrowsebase", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (Class< IoConnectionRef >, IoConnectionBaseClass, "net.maxon.class.ioconnectionbase", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (Class< IoConnectionRef >, IoConnectionFileClass, "net.maxon.class.ioconnectionfile", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
enum maxon::IOTIMEMODE MAXON_ENUM_LIST (IOTIMEMODE, "net.maxon.datatype.enum.iotimemode")
 
enum maxon::URLCOMPARE MAXON_ENUM_LIST (URLCOMPARE, "net.maxon.datatype.enum.urlcompare")
 
enum maxon::IODETECT MAXON_ENUM_LIST (IODETECT, "net.maxon.datatype.enum.iodetect")
 
enum maxon::OPENSTREAMFLAGS MAXON_ENUM_FLAGS (OPENSTREAMFLAGS, "net.maxon.datatype.enum.openstreamflags")
 
enum maxon::NORMALIZEFLAGS MAXON_ENUM_FLAGS (NORMALIZEFLAGS, "net.maxon.datatype.enum.normalizeflags")
 
enum maxon::IOATTRIBUTES UInt MAXON_ENUM_FLAGS (IOATTRIBUTES, "net.maxon.datatype.enum.ioattributes")
 
void ConvertIoAttributes (IOATTRIBUTES &attributes)
 
enum maxon::IOSHOWINOSFLAGS MAXON_ENUM_FLAGS (IOSHOWINOSFLAGS, "net.maxon.datatype.enum.ioshowinosflags")
 
 MAXON_REGISTRY (IoHandler, IoHandlers, "net.maxon.registry.iohandlers")
 
 MAXON_DECLARATION (Class< IoHandler >, IoHandlerObjectBaseClass, "net.maxon.class.iohandlerobjectbase", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (Class< IoHandler >, IoHandlerObjectFileClass, "net.maxon.class.iohandlerobjectfile", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
Result< UrlCreateMemoryFileWithSuffix (const String &suffix=String())
 
 MAXON_DECLARATION (Class< IoDualInOutputStreamRef >, InOutputStreamDualClass, "net.maxon.class.inoutputstreamdual", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (Class< IoError >, IoErrorObjectClass, "net.maxon.class.ioerrorobject", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (Class< InputStreamRef >, InputStreamBaseClass, "net.maxon.class.inputstreambase", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (Class< OutputStreamRef >, OutputStreamBaseClass, "net.maxon.class.outputstreambase", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (Class< InOutputStreamRef >, InOutputStreamBaseClass, "net.maxon.class.inoutputstreambase", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (Class< InputStreamRef >, InputStreamDecoratorBaseClass, "net.maxon.class.inputstreamdecorator", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (Class< OutputStreamRef >, OutputStreamDecoratorBaseClass, "net.maxon.class.outputstreamdecorator", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (Class< InOutputStreamRef >, InOutputStreamDecoratorBaseClass, "net.maxon.class.inoutputstreamdecorator", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
Result< IntInt64ToInt (Int64 value)
 
template<typename FN >
auto ExecuteOnMainThread (FN &&fn, WAITMODE waitMode=WAITMODE::DEFAULT, TimeValue wait=TIMEVALUE_INFINITE) -> decltype(fn())
 
 MAXON_DATATYPE (JobRef, "net.maxon.datatype.job", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
enum maxon::JOBGROUPFLAGS MAXON_ENUM_FLAGS (JOBGROUPFLAGS)
 
enum maxon::JOBGROUPADDFLAGS MAXON_ENUM_FLAGS (JOBGROUPADDFLAGS)
 
enum maxon::STATICJOBGROUPFLAGS MAXON_ENUM_FLAGS (STATICJOBGROUPFLAGS)
 
enum maxon::STATICJOBARRAYFLAGS MAXON_ENUM_FLAGS (STATICJOBARRAYFLAGS)
 
enum maxon::JOBQUEUETYPE MAXON_ENUM_LIST (JOBQUEUETYPE)
 
enum maxon::JOBQUEUEMODE MAXON_ENUM_LIST (JOBQUEUEMODE)
 
enum maxon::LEXERSYMBOL UChar MAXON_ENUM_LIST (LEXERSYMBOL)
 
enum maxon::LEXERSYMBOLFLAGS MAXON_ENUM_FLAGS (LEXERSYMBOLFLAGS)
 
enum maxon::LEXERINITFLAGS MAXON_ENUM_FLAGS (LEXERINITFLAGS)
 
template<typename FLOAT >
SqrMat3< Vec3< FLOAT > > VectorToSquareMatrix (const Vec3< FLOAT > &dirVector, const Vec3< FLOAT > &upVector)
 
template<typename FLOAT >
SqrMat3< Vec3< FLOAT > > CheckedVectorToSquareMatrix (const Vec3< FLOAT > &dirVector, const Vec3< FLOAT > &upVector)
 
template<typename FLOAT >
Mat3< Vec3< FLOAT > > VectorToMatrix (const Vec3< FLOAT > &dirVector, const Vec3< FLOAT > &upVector)
 
template<typename FLOAT >
Mat3< Vec3< FLOAT > > GetTranslationMatrix (const Vec3< FLOAT > &translation)
 
template<typename FLOAT >
SqrMat3< Vec3< FLOAT > > GetScaleMatrix (const Vec3< FLOAT > &scale)
 
template<typename FLOAT >
SqrMat3< Vec3< FLOAT > > GetRotationMatrixX (FLOAT angle)
 
template<typename FLOAT >
SqrMat3< Vec3< FLOAT > > GetRotationMatrixY (FLOAT angle)
 
template<typename FLOAT >
SqrMat3< Vec3< FLOAT > > GetRotationMatrixZ (FLOAT angle)
 
template<typename FLOAT >
Mat2< Vec2< FLOAT > > GetTranslationMatrix (const Vec2< FLOAT > &translation)
 
template<typename FLOAT >
SqrMat2< Vec2< FLOAT > > GetScaleMatrix (const Vec2< FLOAT > &scale)
 
template<typename FLOAT >
SqrMat2< Vec2< FLOAT > > GetRotationMatrix (FLOAT angle)
 
enum maxon::ROTATIONORDER MAXON_ENUM_LIST (ROTATIONORDER)
 
template<typename FLOAT >
Vec3< FLOAT > GetRotationAngles (const SqrMat3< Vec3< FLOAT >> &m, ROTATIONORDER rotationOrder)
 
template<typename FLOAT >
Vec3< FLOAT > GetRotationAngles (const Vec3< FLOAT > &direction, ROTATIONORDER rotationOrder)
 
template<typename FLOAT >
SqrMat3< Vec3< FLOAT > > GetRotationMatrix (const Vec3< FLOAT > &rotation, ROTATIONORDER rotationOrder)
 
template<typename FLOAT >
Mat3< Vec3< FLOAT > > GetPSRMatrix (const Vec3< FLOAT > &position, const Vec3< FLOAT > &scale, const Vec3< FLOAT > &rotation, ROTATIONORDER rotationOrder)
 
template<typename FLOAT >
Vec3< FLOAT > GetOptimumRotation (const Vec3< FLOAT > &oldRotation, const Vec3< FLOAT > &newRotation, ROTATIONORDER rotationOrder)
 
template<typename FLOAT >
Vec3< FLOAT > GetClosestPointOnLine (const Vec3< FLOAT > &lineOrigin, const Vec3< FLOAT > &lineDirection, const Vec3< FLOAT > &point)
 
template<typename FLOAT >
FLOAT GetPointLineDistance (const Vec3< FLOAT > &lineOrigin, const Vec3< FLOAT > &lineDirection, const Vec3< FLOAT > &point)
 
template<typename FLOAT >
Vec3< FLOAT > ReflectRay (const Vec3< FLOAT > &direction, const Vec3< FLOAT > &normal)
 
template<typename FLOAT >
Vec3< FLOAT > RGBToHSV (const Col3< FLOAT > &color)
 
template<typename FLOAT >
Col3< FLOAT > HSVToRGB (const Vec3< FLOAT > &color)
 
template<typename FLOAT >
Vec3< FLOAT > RGBToHSL (const Col3< FLOAT > &color)
 
template<typename FLOAT >
Col3< FLOAT > HSLToRGB (const Vec3< FLOAT > &color)
 
template<typename FLOAT >
void GetRotationAxis (const SqrMat3< Vec3< FLOAT >> &m, Vec3< FLOAT > &axisVector, FLOAT &axisRotation)
 
template<typename FLOAT >
SqrMat3< Vec3< FLOAT > > GetRotationMatrixFromAxis (const Vec3< FLOAT > &axisVector, FLOAT axisRotation)
 
template<typename MATRIXTYPE >
Bool IsMatrixRectangular (const MATRIXTYPE &m, typename MATRIXTYPE::ValueType epsilon=1e-10_f)
 
template<typename ITERABLETYPE >
MAXON_ATTRIBUTE_FORCE_INLINE std::remove_reference< ITERABLETYPE >::type::ValueType GetSum (ITERABLETYPE &&array)
 
template<typename ITERABLETYPE >
MAXON_ATTRIBUTE_FORCE_INLINE std::remove_reference< ITERABLETYPE >::type::ValueType GetAverage (ITERABLETYPE &&array)
 
Result< void > PrivateConsoleOutput (const String &str, const SourceLocation &loc, WRITEMETA level)
 
 MAXON_DECLARATION (Class< LoggerTypeRef >, LoggerTypeBaseClass, "net.maxon.class.loggertypebase", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_REGISTRY (Class< LoggerTypeRef >, LoggerTypes, "net.maxon.core.registry.loggertypes")
 
 MAXON_REGISTRY (LoggerRef, Loggers, "net.maxon.core.registry.loggers")
 
enum maxon::MACHINESTATE MAXON_ENUM_FLAGS (MACHINESTATE)
 
 MAXON_DECLARATION (Class< MachineRef >, LocalMachineClass, "net.maxon.class.localmachine", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DATATYPE (CreateObjectRefFunc, "net.maxon.datatype.createobjectreffunc", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_REGISTRY (CreateObjectRefFunc, MachineImplementationFactories, "net.maxon.registry.machineimplementationfactories")
 
template<typename MAP >
 MAXON_IMPLEMENTATION_SIMPLE_REGISTER (MapImpl< MAP >)
 
template<typename K , typename V >
const MapInterface< K, V > * ToMapPtr (const MapInterface< K, V > &map)
 
template<typename K , typename V >
WritableMapInterface< K, V > * ToWritableMapPtr (WritableMapInterface< K, V > &map)
 
template<typename T , Int STR, typename S >
Col3< typename MultiplicativePromotion< T, S, STD_IS_REPLACEMENT(scalar, S)>::type, 1 > operator* (S s, const Col3< T, STR > &v)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataTypePrivateGetDataType (Col3< T, 1 > **, OverloadRank1)
 
template<typename T , Int STR, typename S >
Col4< typename MultiplicativePromotion< T, S, STD_IS_REPLACEMENT(scalar, S)>::type, 1 > operator* (S s, const Col4< T, STR > &v)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataTypePrivateGetDataType (Col4< T, 1 > **, OverloadRank1)
 
template<typename T , Int STR, typename S >
Vec3< typename MultiplicativePromotion< T, S, STD_IS_REPLACEMENT(scalar, S)>::type, 1 > operator* (S s, const Vec3< T, STR > &v)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataTypePrivateGetDataType (Vec3< T, 1 > **, OverloadRank1)
 
template<typename T , Int STR, typename S , typename SPACE >
Vec2< typename MultiplicativePromotion< T, S, STD_IS_REPLACEMENT(scalar, S)>::type, 1, SPACE > operator* (S s, const Vec2< T, STR, SPACE > &v)
 
template<GET_DATATYPE_POLICY POLICY, typename T , typename SPACE >
Result< DataTypePrivateGetDataType (Vec2< T, 1, SPACE > **, OverloadRank1)
 
template<typename T , Int STR, typename S >
Vec4< typename MultiplicativePromotion< T, S, STD_IS_REPLACEMENT(scalar, S)>::type, 1 > operator* (S s, const Vec4< T, STR > &v)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataTypePrivateGetDataType (Vec4< T, 1 > **, OverloadRank1)
 
template<typename V , typename V2 >
Mat3< typename MultiplicativePromotion< V, typename V2::ValueType >::typeoperator* (const SqrMat3< V > &m, const Mat3< V2 > &m2)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataTypePrivateGetDataType (SqrMat3< T > **, OverloadRank1)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataTypePrivateGetDataType (Mat3< T > **, OverloadRank1)
 
template<typename V , typename V2 >
Mat2< typename MultiplicativePromotion< V, typename V2::ValueType >::typeoperator* (const SqrMat2< V > &m, const Mat2< V2 > &m2)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataTypePrivateGetDataType (SqrMat2< T > **, OverloadRank1)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataTypePrivateGetDataType (Mat2< T > **, OverloadRank1)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataTypePrivateGetDataType (SqrMat4< T > **, OverloadRank1)
 
 MAXON_REGISTRY (DataDictionary, ModuleVersionInfos, "net.maxon.registry.moduleversioninfos")
 
 MAXON_REGISTRY (Id, ReplaceModule, "net.maxon.registry.replacemodule")
 
template<typename R , typename SRC , typename RESULT = typename maxon::details::CastHelper<R, SRC>::AssertCastType>
RESULT AssertCast (SRC &&ref)
 
template<typename R , typename SRC , typename RESULT = typename maxon::details::CastHelper<R, SRC>::type>
RESULT Cast (SRC &&ref)
 
template<typename R , typename SRC , typename RESULT = typename maxon::details::CastHelper<R, SRC>::type>
Result< RESULT > Cast (Result< SRC > &&src)
 
template<typename R , typename SRC , typename RESULT = typename maxon::details::CastHelper<R, SRC>::type>
Result< RESULT > AssertCast (Result< SRC > &&src)
 
 MAXON_REGISTRY (Class<>, Classes, "net.maxon.registry.classes")
 
 MAXON_REGISTRY (ClassTransformer, ClassTransformers, "net.maxon.registry.classtransformers")
 
 MAXON_DECLARATION (Class< ObjectRef >, ObjectBaseClass, "net.maxon.class.object", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
class ComponentRoot MAXON_IF_TARGET_DEBUG (:public EmptyVirtualClass,)
 
constexpr const CharGetFunctionName (const Char *funcName)
 
 MAXON_DECLARATION (ComponentDescriptor, ObservableCombinerRunAllComponent, "net.maxon.component.observablecombinerrunall", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (ComponentDescriptor, ObservableCombinerRunAllBoolOrComponent, "net.maxon.component.observablecombinerrunallboolor", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (ComponentDescriptor, ObservableCombinerRunAllBoolUntilFalse, "net.maxon.component.observablecombinerrunallbooluntilfalse", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (ComponentDescriptor, ObservableCombinerRunAllBoolUntilTrue, "net.maxon.component.observablecombinerrunallbooluntiltrue", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (ComponentDescriptor, ObservableCombinerRunAllEnumFlagsOrComponent, "net.maxon.component.observablecombinerrunallenumflagsor", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (ComponentDescriptor, ObservableCombinerRunAllEnumFlags64OrComponent, "net.maxon.component.observablecombinerrunallenumflags64or", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (ComponentDescriptor, ObservableCombinerRunAllAggregateErrorsComponent, "net.maxon.component.observablecombinerrunallaggregateerrors", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (Class< FunctionBaseRef >, FunctionBaseClass, "net.maxon.class.functionbase", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (Class< ObservableBaseRef >, ObservableClass, "net.maxon.class.observable", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (Class< ObserverObjectRef >, ObserverObjectClass, "net.maxon.class.observerobject", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
enum maxon::NO_VALUE_TYPE MAXON_ENUM_LIST (NO_VALUE_TYPE)
 
template<typename T >
Bool operator== (const Opt< T > &lhs, const Opt< T > &rhs)
 
template<typename T >
Bool operator== (const Opt< T > &opt, NO_VALUE_TYPE)
 
template<typename T >
Bool operator== (NO_VALUE_TYPE, const Opt< T > &opt)
 
template<typename T >
Bool operator!= (const Opt< T > &opt, NO_VALUE_TYPE)
 
template<typename T >
Bool operator!= (NO_VALUE_TYPE, const Opt< T > &opt)
 
enum maxon::PARALLELFORFLAGS MAXON_ENUM_FLAGS (PARALLELFORFLAGS)
 
template<typename... ARGS>
Result< void > ParallelInvoke (Bool parallel, ARGS &&... args)
 
 MAXON_REGISTRY (ParametricType, ParametricTypes, "net.maxon.registry.parametrictypes")
 
enum maxon::PARSERFLAGS MAXON_ENUM_FLAGS (PARSERFLAGS)
 
 MAXON_REGISTRY (Class< ParserRef >, ParserClasses, "net.maxon.interface.registry.parserclasses")
 
 MAXON_DECLARATION (Class< ParserRef >, ParserBaseClass, "net.maxon.interface.parserclass.base", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
MAXON_ATTRIBUTE_FORCE_INLINE Bool atomic_try_cas32 (Int32 volatile *dst, Int32 xchg, Int32 cmp)
 
MAXON_ATTRIBUTE_FORCE_INLINE Bool atomic_try_cas32HLE (Int32 volatile *dst, Int32 xchg, Int32 cmp)
 
MAXON_ATTRIBUTE_FORCE_INLINE Char atomic_swap_add8 (Char volatile *dst, Char value)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int16 atomic_swap_add16 (Int16 volatile *dst, Int16 value)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int32 atomic_swap_add32 (Int32 volatile *dst, Int32 value)
 
MAXON_ATTRIBUTE_FORCE_INLINE Char atomic_swap8 (Char volatile *dst, Char value)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int16 atomic_swap16 (Int16 volatile *dst, Int16 value)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int32 atomic_swap32 (Int32 volatile *dst, Int32 value)
 
MAXON_ATTRIBUTE_FORCE_INLINE Bool atomic_try_cas64 (Int64 volatile *dst, Int64 xchg, Int64 cmp)
 
MAXON_ATTRIBUTE_FORCE_INLINE Bool atomic_try_cas64HLE (Int64 volatile *dst, Int64 xchg, Int64 cmp)
 
MAXON_ATTRIBUTE_FORCE_INLINE Bool atomic_try_cas128 (Int64 volatile *dst, Int64 xchghi, Int64 xchglo, Int64 cmphi, Int64 cmplo)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int64 atomic_swap_add64 (Int64 volatile *dst, Int64 value)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int64 atomic_swap64 (Int64 volatile *dst, Int64 value)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int32 atomic_swap_or32 (Int32 volatile *dst, Int32 mask)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int32 atomic_swap_and32 (Int32 volatile *dst, Int32 mask)
 
MAXON_ATTRIBUTE_FORCE_INLINE Bool atomic_try_cas8 (Char volatile *dst, Char xchg, Char cmp)
 
MAXON_ATTRIBUTE_FORCE_INLINE Bool atomic_try_cas16 (Int16 volatile *dst, Int16 xchg, Int16 cmp)
 
MAXON_ATTRIBUTE_FORCE_INLINE Char atomic_consume_load8 (Char volatile *src)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int16 atomic_consume_load16 (Int16 volatile *src)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int32 atomic_consume_load32 (Int32 volatile *src)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int64 atomic_consume_load64 (Int64 volatile *src)
 
MAXON_ATTRIBUTE_FORCE_INLINE Char atomic_acquire_load8 (Char volatile *src)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int16 atomic_acquire_load16 (Int16 volatile *src)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int32 atomic_acquire_load32 (Int32 volatile *src)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int64 atomic_acquire_load64 (Int64 volatile *src)
 
MAXON_ATTRIBUTE_FORCE_INLINE Char atomic_sequential_load8 (Char volatile *src)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int16 atomic_sequential_load16 (Int16 volatile *src)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int32 atomic_sequential_load32 (Int32 volatile *src)
 
MAXON_ATTRIBUTE_FORCE_INLINE Int64 atomic_sequential_load64 (Int64 volatile *src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void atomic_release_store8 (Char volatile *dst, Char value)
 
MAXON_ATTRIBUTE_FORCE_INLINE void atomic_release_store16 (Int16 volatile *dst, Int16 value)
 
MAXON_ATTRIBUTE_FORCE_INLINE void atomic_release_store32 (Int32 volatile *dst, Int32 value)
 
MAXON_ATTRIBUTE_FORCE_INLINE void atomic_release_store32HLE (Int32 volatile *dst, Int32 value)
 
MAXON_ATTRIBUTE_FORCE_INLINE void atomic_release_store64 (Int64 volatile *dst, Int64 value)
 
MAXON_ATTRIBUTE_FORCE_INLINE void atomic_release_store64HLE (Int64 volatile *dst, Int64 value)
 
MAXON_ATTRIBUTE_FORCE_INLINE void atomic_sequential_store8 (Char volatile *dst, Char value)
 
MAXON_ATTRIBUTE_FORCE_INLINE void atomic_sequential_store16 (Int16 volatile *dst, Int16 value)
 
MAXON_ATTRIBUTE_FORCE_INLINE void atomic_sequential_store32 (Int32 volatile *dst, Int32 value)
 
MAXON_ATTRIBUTE_FORCE_INLINE void atomic_sequential_store64 (Int64 volatile *dst, Int64 value)
 
 MAXON_DECLARATION (Class< ProgressRef >, ProgressObject, "net.maxon.image.class.mediasessionprogressobject", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<typename T >
PrivateRangeValueTypeHelper (OverloadRank0)
 
template<typename T >
T::ValueType PrivateRangeValueTypeHelper (OverloadRank1)
 
template<GET_DATATYPE_POLICY POLICY, typename T >
Result< DataTypePrivateGetDataType (Range< T > **, OverloadRank0)
 
template<typename RANGETYPE >
Int GetRangeItemCount (const RANGETYPE &data)
 
template<typename SET >
 MAXON_IMPLEMENTATION_SIMPLE_REGISTER (SetImpl< SET >)
 
template<typename T >
const SetInterface< T > * ToSetPtr (const SetInterface< T > &set)
 
template<typename T >
WritableSetInterface< T > * ToWritableSetPtr (WritableSetInterface< T > &set)
 
enum maxon::ACCESSLEVEL MAXON_ENUM_LIST (ACCESSLEVEL)
 
enum maxon::BASESORTFLAGS MAXON_ENUM_FLAGS (BASESORTFLAGS)
 
template<typename T , typename GETINT >
Int32 DetermineByteDigit (Int32 stage, T num, GETINT &&getInt)
 
template<typename T , typename GETINT >
Bool Compare (const T &x, const T &y, GETINT &&getInt)
 
template<typename T , typename GETINT >
void InsertSort (Block< T > data, Int32 start, Int32 end, GETINT &&getInt)
 
template<int kth_byte, typename T , typename GETINT >
MAXON_ATTRIBUTE_NO_INLINE Result< void > ParadisByte (Int32 start, Int32 target, Block< T > data, GETINT &&getInt, JobQueueRef &jobQueue, Int32 processes=1)
 
template<typename T , typename GETINT >
Result< void > Paradis (const Block< T > &data, UInt32 threadNum, GETINT &&getInt)
 
Vector4f32 LoadVector4f32 (const Vector64 &v, Float64 w, Bool aligned)
 
Vector4f32 LoadVector4f32 (const Vector32 &v, Float32 w, Bool aligned)
 
Vector4f32 LoadVector4f32 (const Vector4d64 &v, Bool aligned)
 
Vector4f32 LoadVector4f32 (const Vector4d32 &v, Bool aligned)
 
Vector4f32 LoadVector4f32 (const Color64 &v, Float64 w, Bool aligned)
 
Vector4f32 LoadVector4f32 (const Color32 &v, Float32 w, Bool aligned)
 
Vector4f32 LoadVector4f32 (const ColorA64 &v, Bool aligned)
 
Vector4f32 LoadVector4f32 (const ColorA32 &v, Bool aligned)
 
UInt64 _mm_crc32_u64 (UInt64 c, UInt64 d)
 
unsigned int _mm_crc32_u32 (UInt32 c, UInt32 d)
 
unsigned int _mm_crc32_u16 (UInt32 c, UInt16 d)
 
unsigned int _mm_crc32_u8 (UInt32 c, UChar d)
 
MAXON_ATTRIBUTE_FORCE_INLINE Vector4f32 CastToVector4f32 (const Vector4i32 &a)
 
MAXON_ATTRIBUTE_FORCE_INLINE Vector4f32 ConvertToVector4f32 (const Vector4i32 &a)
 
MAXON_ATTRIBUTE_FORCE_INLINE Vector4i32 CastToVector4i32 (const Vector4f32 &a)
 
MAXON_ATTRIBUTE_FORCE_INLINE Vector4i32 ConvertToVector4i32 (const Vector4f32 &a)
 
MAXON_ATTRIBUTE_FORCE_INLINE Vector4f32 ConvertToVector4f32 (const Vector2f64 &a, const Vector2f64 &b)
 
MAXON_ATTRIBUTE_FORCE_INLINE Vector4f32 ConvertToVector4f32 (const Vector2f64 &a)
 
 MAXON_REGISTRY (StreamConversionFactory, StreamConversions, "net.maxon.registry.streamconversions")
 
 MAXON_DATATYPE (ConversionTestSet, "net.maxon.datatype.conversiontestset", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_REGISTRY (Factory< BaseArray< DataDictionary >()>, StreamConversionTests, "net.maxon.registry.streamconversiontests")
 
template<typename SRCTYPE , typename DSTTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Result< void > AddConversionTestSettingT (MAXON_SOURCE_LOCATION_DECLARATION, BaseArray< DataDictionary > &resultArray, const Block< const ConversionTestSet > &set, const Block< const SRCTYPE > &srcData, const Block< const DSTTYPE > &compareData, Bool forbidLargeTest=false)
 
template<typename SLOC >
Result< void > AddConversionTestSetting (const SLOC &allocLocation, BaseArray< DataDictionary > &resultArray, const Block< const ConversionTestSet > &set, const Block< const Char > &srcData, const Block< const Char > &compareData, Bool forbidLargeTest=false)
 
template<typename SLOC >
Result< void > AddConversionTestSetting (const SLOC &allocLocation, BaseArray< DataDictionary > &resultArray, const Block< const ConversionTestSet > &set, const Block< const Utf32Char > &srcData, const Block< const Char > &compareData, Bool forbidLargeTest=false)
 
template<typename SLOC >
Result< void > AddConversionTestSetting (const SLOC &allocLocation, BaseArray< DataDictionary > &resultArray, const Block< const ConversionTestSet > &set, const Block< const Char > &srcData, const Block< const Utf32Char > &compareData, Bool forbidLargeTest=false)
 
template<typename SLOC >
Result< void > AddConversionTestSetting (const SLOC &allocLocation, BaseArray< DataDictionary > &resultArray, const Block< const ConversionTestSet > &set, const Block< const Utf32Char > &srcData, const Block< const Utf32Char > &compareData, Bool forbidLargeTest=false)
 
template<typename TO , typename FROM >
Factory< TO(const DataDictionary &)> & ConvertStreamConversionRef (FROM &obj)
 
 MAXON_DECLARATION (Class< StreamConversionRef >, StreamConversionBaseClass, "net.maxon.class.streamconversionbase", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
const StringDecodingRef & GetUtf8DefaultDecoder ()
 
const StringEncodingRef & GetUtf8DefaultEncoder ()
 
enum maxon::STRINGCONVERSION MAXON_ENUM_FLAGS (STRINGCONVERSION)
 
enum maxon::STRINGCOMPARISON MAXON_ENUM_LIST (STRINGCOMPARISON)
 
MAXON_ATTRIBUTE_FORCE_INLINE const Stringoperator""_s (const char *str, std::size_t cnt)
 
MAXON_ATTRIBUTE_FORCE_INLINE const Stringoperator""_s (const wchar_t *str, std::size_t cnt)
 
MAXON_ATTRIBUTE_FORCE_INLINE const CStringoperator""_cs (const char *str, std::size_t cnt)
 
Result< void > DescribeIO (const CStringInterface &s, const DataSerializeInterface &dsi)
 
Result< void > DescribeIO (const StringInterface &s, const DataSerializeInterface &dsi)
 
String operator+ (const String &a, const String &b)
 
String && operator+ (String &&a, const String &b)
 
String && operator+ (String &&a, String &&b)
 
String && operator+ (const String &a, String &&b)
 
CString operator+ (const CString &a, const CString &b)
 
CString && operator+ (CString &&a, const CString &b)
 
CString && operator+ (CString &&a, CString &&b)
 
CString && operator+ (const CString &a, CString &&b)
 
Stringoperator+= (String &s, const CString &b)
 
String operator+ (const String &a, const CString &b)
 
String && operator+ (String &&a, const CString &b)
 
String operator+ (const String &a, const Char *b)
 
String && operator+ (String &&a, const Char *b)
 
CString operator+ (const CString &a, const Char *b)
 
CString && operator+ (CString &&a, const Char *b)
 
String ToString (const String &str, const FormatStatement *formatStatement, Bool=false)
 
String ToString (const CString &str, const FormatStatement *formatStatement, Bool=false)
 
template<typename T >
decltype(std::declval< T >().ToString()) ToStringHelper (const T *object, const FormatStatement *formatStatement, Int *)
 
template<typename T >
String ToStringHelper (const T *object, const FormatStatement *formatStatement, const Int *checkDataType)
 
template<typename T >
std::enable_if<!STD_IS_REPLACEMENT(enum, T), String >::type ToString (const T &object, const FormatStatement *formatStatement, Bool checkDataType=true)
 
template<typename T >
std::enable_if< STD_IS_REPLACEMENT(enum, T), String >::type ToString (const T &object, const FormatStatement *formatStatement, Bool checkDataType=true)
 
template<typename T >
std::enable_if<!STD_IS_REPLACEMENT(function, T), String >::type ToString (const T *object, const FormatStatement *formatStatement)
 
const StringToString (Bool val, const FormatStatement *formatStatement, Bool=false)
 
String ToString (Char val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (UChar val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (Int16 val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (Int32 val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (Int64 val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (UInt16 val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (UInt32 val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (UInt64 val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (Float64 val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (Float32 val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (Utf16Char val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (Utf32Char val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (Char *val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (const Char *val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (const void *val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (void *val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (const Generic *val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (Generic *val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ExtractString (StringProxy *proxy)
 
const StringExtractString (const String &str)
 
const CharExtractString (const Char *str)
 
void ScanParameter (Float64 &result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
void ScanParameter (Float32 &result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
void ScanParameter (Int64 &result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
void ScanParameter (Int32 &result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
void ScanParameter (Int16 &result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
void ScanParameter (Char &result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
void ScanParameter (UInt64 &result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
void ScanParameter (UInt32 &result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
void ScanParameter (UInt16 &result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
void ScanParameter (UChar &result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
template<typename T >
void ScanParameter (T *&result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
template<typename T >
void FromStrHlp (T *result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
template<typename T >
FROMSTR GetFromStrHlp ()
 
Bool ScanStringTemplate (const String &str, const String &format, Int *parsedCharacters, Int argsCnt, void **args, FROMSTR *argFuncs)
 
CString ExtractCString (StringProxy *proxy)
 
template<Bool ISOKAY, typename T >
MAXON_ATTRIBUTE_FORCE_INLINEForwardString (T &&str)
 
template<typename STR , typename STR2 , typename... ARGS>
Bool ScanString (STR inputStr, STR2 formatStr, ARGS &... args)
 
template<typename STR , typename STR2 , typename... ARGS>
Bool ScanString (STR inputStr, Int &parsedInputCharacters, STR2 formatStr, ARGS &... args)
 
String _LoadResourceString (const Id &scope, const InternedId &keyValue)
 
template<typename STRID , typename... ARGUMENTS>
String LoadResourceString (const STRID &identifier, const ARGUMENTS &... args)
 
static Int StrLen (const SysChar *chr)
 
static Int StrLen (const Utf32Char *chr)
 
static Int StrLen (const Utf16Char *chr)
 
template<typename TYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsSpace (TYPE chr)
 
template<typename TYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsTab (TYPE chr)
 
template<typename TYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsSpaceOrTab (TYPE chr)
 
template<typename TYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsLineEnd (TYPE chr)
 
template<typename TYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsNumeric (TYPE chr)
 
template<typename TYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsAlphabetic (TYPE chr)
 
template<typename TYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsAlphanumeric (TYPE chr)
 
template<typename TYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsHexadecimal (TYPE chr)
 
template<typename TYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Int GetHexadecimalValue (TYPE chr)
 
template<typename ITERATABLETYPE , typename REFTYPE >
static MAXON_WARN_UNUSED REFTYPE JoinElements (ITERATABLETYPE &&iterable, const REFTYPE &delimiter, const FormatStatement *formatStr=nullptr)
 
template<typename STRINGTYPE >
void AppendStringWithSeparator (STRINGTYPE &base, const STRINGTYPE &add, const STRINGTYPE &delimiter)
 
template<typename STRINGTYPE >
STRINGTYPE AddStringWithSeparator (const STRINGTYPE &base, const STRINGTYPE &add, const STRINGTYPE &delimiter)
 
 MAXON_REGISTRY (StringEncodingRef, StringEncodings, "net.maxon.registry.stringencodings")
 
 MAXON_REGISTRY (StringDecodingRef, StringDecodings, "net.maxon.registry.stringdecodings")
 
 MAXON_MEMBERFUNCTION_DETECTOR (GetReferenceCounter)
 
enum maxon::EXECUTEPROGRAMFLAGS MAXON_ENUM_FLAGS (EXECUTEPROGRAMFLAGS)
 
enum maxon::EXECUTEPROGRAMCALLBACK MAXON_ENUM_LIST (EXECUTEPROGRAMCALLBACK)
 
enum maxon::WAIT_PROCESS_RESULT MAXON_ENUM_LIST (WAIT_PROCESS_RESULT)
 
 MAXON_DECLARATION (Class< SystemProcessObjectRef >, SystemProcessObjectClass, "net.maxon.class.systemprocessobject", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<typename T , typename HANDLER , typename TAG , Int TAG_BITS, TAG DEFAULT_VALUE, Bool ENABLE_POINTER_CONVERSION>
SFINAEHelper< String, T >::type ToString (const TaggedBaseRef< T, HANDLER, TAG, TAG_BITS, DEFAULT_VALUE, ENABLE_POINTER_CONVERSION > &object, const FormatStatement *formatStatement, Bool checkDataType=true)
 
 MAXON_DATATYPE (ThreadRef, "net.maxon.datatype.threadref", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
enum maxon::THREADPRIORITY Int16 MAXON_ENUM_LIST (THREADPRIORITY)
 
enum maxon::WAITMODE MAXON_ENUM_FLAGS (WAITMODE)
 
enum maxon::THREADTYPE MAXON_ENUM_LIST (THREADTYPE)
 
enum maxon::TIMEFORMAT MAXON_ENUM_LIST (TIMEFORMAT)
 
constexpr Hours operator""_h (long double value)
 
constexpr Minutes operator""_min (long double value)
 
constexpr Seconds operator""_sec (long double value)
 
constexpr Milliseconds operator""_ms (long double value)
 
constexpr Microseconds operator""_us (long double value)
 
constexpr Nanoseconds operator""_ns (long double value)
 
 MAXON_DATATYPE (TimeValue, "net.maxon.datatype.timevalue", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
template<Int I, typename ... TYPES>
auto TupleGet (const Tuple< TYPES ... > &tup) -> const typename ParameterPack< TYPES... >::template At< I >::type &
 
template<Int I, typename ... TYPES>
auto TupleGet (Tuple< TYPES ... > &tup) -> typename ParameterPack< TYPES... >::template At< I >::type &
 
template<Int I, typename ... TYPES>
auto TupleGet (Tuple< TYPES ... > &&tup) -> typename ParameterPack< TYPES... >::template At< I >::type &&
 
template<typename F , typename ... TYPES>
auto TupleExpand (const Tuple< TYPES ... > &tup, F &&func) -> decltype(maxon::details::ExpandSeqHelperConst(tup, std::forward< F >(func), std::make_index_sequence< sizeof...(TYPES)>()))
 
template<typename F , typename ... TYPES>
auto TupleExpand (Tuple< TYPES ... > &tup, F &&func) -> decltype(maxon::details::ExpandSeqHelper(tup, std::forward< F >(func), std::make_index_sequence< sizeof...(TYPES)>()))
 
template<typename F , typename ... TYPES>
auto TupleExpand (Tuple< TYPES ... > &&tup, F &&func) -> decltype(maxon::details::ExpandSeqHelper(std::move(tup), std::forward< F >(func), std::make_index_sequence< sizeof...(TYPES)>()))
 
template<typename ... TYPES>
auto ToTuple (TYPES &&... args) -> Tuple< typename std::decay< TYPES >::type ... >
 
template<typename... TYPES>
auto Tie (TYPES &... args) -> Tuple< TYPES &... >
 
template<typename... TYPES>
auto ToForwardTuple (TYPES &&... args) -> Tuple< TYPES &&... >
 
template<typename F , typename ... TYPES>
void TupleForEach (const Tuple< TYPES ... > &tup, F &&func)
 
template<typename F , typename ... TYPES>
void TupleForEach (Tuple< TYPES ... > &tup, F &&func)
 
template<typename F , typename ... TYPES>
void TupleForEach (Tuple< TYPES ... > &&tup, F &&func)
 
template<typename V , typename F , typename ... TYPES>
auto TupleFold (const Tuple< TYPES ... > &tup, const V &initialValue, F &&func) -> V
 
template<typename V , typename F , typename ... TYPES>
auto TupleFold (Tuple< TYPES ... > &tup, const V &initialValue, F &&func) -> V
 
template<typename V , typename F , typename ... TYPES>
auto TupleFold (Tuple< TYPES ... > &&tup, const V &initialValue, F &&func) -> V
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE Id GetTypeName ()
 
enum maxon::NORMALIZATION MAXON_ENUM_LIST (NORMALIZATION)
 
enum maxon::CHARACTERTYPE UChar MAXON_ENUM_LIST (CHARACTERTYPE)
 
template<typename TYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsUnicodeLetter (TYPE chr)
 
enum maxon::BASE_DIMENSION MAXON_ENUM_LIST (BASE_DIMENSION)
 
 MAXON_REGISTRY (Dimension, Dimensions, "net.maxon.registry.dimensions")
 
 MAXON_REGISTRY (Unit, Units, "net.maxon.registry.units")
 
class IoConnectionRef MAXON_FORWARD ("maxon/ioconnection.h")
 
class IoBrowseRef MAXON_FORWARD ("maxon/iobrowse.h")
 
class UniversalDateTime MAXON_FORWARD ("maxon/datetime.h")
 
enum maxon::GETBROWSEITERATORFLAGS MAXON_ENUM_FLAGS (GETBROWSEITERATORFLAGS)
 
enum maxon::CONVERTTOUINAMEFLAGS MAXON_ENUM_FLAGS (CONVERTTOUINAMEFLAGS)
 
 MAXON_REGISTRY (UrlIoShowInOSDelegate, UrlIoShowInOSRegistry, "net.maxon.registry.urlioshowinos")
 
enum maxon::URLFILECACHEFLAGS MAXON_ENUM_FLAGS (URLFILECACHEFLAGS)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Clamp01 (Float32 a)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Clamp01 (Float64 a)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Sin (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Sin (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Cos (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Cos (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Tan (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Tan (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 ATan (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 ATan (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 ATan2 (Float32 valY, Float32 valX)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 ATan2 (Float64 valY, Float64 valX)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Exp (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Exp (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Exp2 (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Exp2 (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Ln (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Ln (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Log10 (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Log10 (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Log2 (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Log2 (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Sqrt (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Sqrt (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Floor (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Floor (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Ceil (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Ceil (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Round (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Round (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Pow (Float32 v1, Float32 v2)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Pow (Float64 v1, Float64 v2)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Sinh (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Sinh (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Cosh (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Cosh (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Tanh (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Tanh (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 FMod (Float32 v1, Float32 v2)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 FMod (Float64 v1, Float64 v2)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Abs (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Abs (Float64 val)
 
constexpr MAXON_ATTRIBUTE_FORCE_INLINE Float32 Inverse (Float32 f)
 
constexpr MAXON_ATTRIBUTE_FORCE_INLINE Float64 Inverse (Float64 f)
 
template<typename X >
constexpr MAXON_ATTRIBUTE_FORCE_INLINEAbs (X f)
 
template<typename X >
constexpr MAXON_ATTRIBUTE_FORCE_INLINEMin (X a, X b)
 
template<typename X >
constexpr MAXON_ATTRIBUTE_FORCE_INLINEMax (X a, X b)
 
template<typename X >
MAXON_ATTRIBUTE_FORCE_INLINE void Swap (X &a, X &b)
 
template<typename X >
MAXON_ATTRIBUTE_FORCE_INLINEClampValue (X value, X lowerLimit, X upperLimit)
 
template<typename X , typename Y >
MAXON_ATTRIBUTE_FORCE_INLINEBlend (const X &value1, const X &value2, Y blendValue)
 
template<typename X >
MAXON_ATTRIBUTE_FORCE_INLINESqr (X a, X b)
 
template<typename X >
MAXON_ATTRIBUTE_FORCE_INLINESqr (X a)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Gamma (Float32 value, Float32 gamma)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Gamma (Float64 value, Float64 gamma)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Si (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Si (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Sinc (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Sinc (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 ASin (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 ASin (Float64 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 ACos (Float32 val)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 ACos (Float64 val)
 
constexpr MAXON_ATTRIBUTE_FORCE_INLINE Float32 DegToRad (Float32 r)
 
constexpr MAXON_ATTRIBUTE_FORCE_INLINE Float64 DegToRad (Float64 r)
 
constexpr MAXON_ATTRIBUTE_FORCE_INLINE Float32 RadToDeg (Float32 r)
 
constexpr MAXON_ATTRIBUTE_FORCE_INLINE Float64 RadToDeg (Float64 r)
 
MAXON_ATTRIBUTE_FORCE_INLINE void SinCos (Float32 val, Float32 &sn, Float32 &cs)
 
MAXON_ATTRIBUTE_FORCE_INLINE void SinCos (Float64 val, Float64 &sn, Float64 &cs)
 
template<typename DEST >
MAXON_ATTRIBUTE_FORCE_INLINE DEST SafeConvert (Float64 src)
 
template<typename DEST >
MAXON_ATTRIBUTE_FORCE_INLINE DEST SafeConvert (Float32 src)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE void SetMax (T &a, const typename SFINAEHelper< T >::type &b)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE void SetMin (T &a, const typename SFINAEHelper< T >::type &b)
 
template<typename X >
MAXON_ATTRIBUTE_FORCE_INLINE Int Sign (X f)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINEMod (T a, T b)
 
constexpr MAXON_ATTRIBUTE_FORCE_INLINE Bool IsPowerOfTwo (UInt32 x)
 
constexpr MAXON_ATTRIBUTE_FORCE_INLINE Bool IsPowerOfTwo (UInt64 x)
 
template<Bool SKIPERRORS = false, typename FN , typename SRC , typename DST >
Result< void > MoveFromWithFilter (DST &dst, SRC &src, const FN &filter)
 
enum maxon::COMPARERESULT int MAXON_ENUM_ORDERED_LIST (COMPARERESULT, "net.maxon.datatype.enum.compareresult", EARLY)
 
Bool operator== (COMPARERESULT a, int b)
 
Bool operator< (COMPARERESULT a, int b)
 
enum maxon::EQUALITY MAXON_ENUM_LIST (EQUALITY, "net.maxon.datatype.enum.equality", EARLY)
 
template<Bool ALLOW_UNDEFINED = false>
Bool LexicographicalGreaterThan ()
 
template<Bool ALLOW_UNDEFINED = false, typename T1 , typename... TN>
Bool LexicographicalGreaterThan (const T1 &a1, const T1 &b1, const TN &... ab)
 
template<Bool ALLOW_UNDEFINED = false>
Bool LexicographicalLessThan ()
 
template<Bool ALLOW_UNDEFINED = false, typename T1 , typename... TN>
Bool LexicographicalLessThan (const T1 &a1, const T1 &b1, const TN &... ab)
 
template<Bool ALLOW_UNDEFINED = false>
COMPARERESULT LexicographicalCompare ()
 
template<Bool ALLOW_UNDEFINED = false, typename T1 , typename... TN>
COMPARERESULT LexicographicalCompare (const T1 &a1, const T1 &b1, const TN &... ab)
 
enum maxon::TARGETAUDIENCE MAXON_ENUM_FLAGS (TARGETAUDIENCE, "net.maxon.datatype.enum.targetaudience", EARLY)
 
enum maxon::WRITEMETA MAXON_ENUM_FLAGS (WRITEMETA, "net.maxon.datatype.enum.writemeta", EARLY)
 
enum maxon::OUTPUT MAXON_ENUM_FLAGS (OUTPUT, "net.maxon.datatype.enum.output", EARLY)
 
void _ConsoleOutput (OUTPUT flags, const Char *str, Int line, const Char *file)
 
void _ConsoleOutput (OUTPUT flags, const String &str, Int line, const Char *file)
 
void _ConsoleOutput (OUTPUT flags, StringProxy *str, Int line, const Char *file)
 
void _ApplicationOutput (maxon::TARGETAUDIENCE t, maxon::WRITEMETA lvl, const maxon::String &str, Int line, const Char *file)
 
void _ApplicationOutput (maxon::TARGETAUDIENCE t, maxon::WRITEMETA lvl, const Char *str, Int line, const Char *file)
 
void _ApplicationOutput (maxon::TARGETAUDIENCE t, maxon::WRITEMETA lvl, const maxon::StringProxy *proxy, Int line, const Char *file)
 
template<typename T >
void ToStrHlp (String &result, const T *x, const FormatStatement *formatStatement)
 
template<typename T >
TOSTR GetToStrHlp ()
 
StringProxyFormat (const String &formatString, Int argsCnt, const void **args, const TOSTR *argFuncs)
 
StringProxyFormat (const Char *formatString, Int argsCnt, const void **args, const TOSTR *argFuncs)
 
template<Int ARGCNT, typename FORMATSTR , typename... ARGS>
StringProxyFormatTemplateX (FORMATSTR formatString, const ARGS &... args)
 
template<Int ARGCNT, typename FORMATSTR >
FORMATSTR FormatTemplateX (FORMATSTR formatString)
 
constexpr Int GetArgCnt (const Char *const formatStr)
 
constexpr bool StrStrConstExpr (const char *str, const char *search)
 
String GetPrintableString (JNIEnv *env, const jstring &val)
 
static String ToString (JNIEnv *env, const jstring &str)
 
template<typename T >
static MAXON_ATTRIBUTE_FORCE_INLINE const CharPrivateGetClassName ()
 
template<typename T >
Result< CopyWrapper< typename std::decay< T >::type > > CreateCopyWrapper (T &&src)
 
template<typename T , typename... ARGS>
ResultPtr< T > NewObjT (ARGS &&... args)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE void DeleteConstPtrObj (T *o)
 
enum maxon::ERROR_OK MAXON_ENUM_LIST (ERROR_OK)
 
enum maxon::ERROR_FAILED MAXON_ENUM_LIST (ERROR_FAILED)
 
enum maxon::ERROR_TYPE MAXON_ENUM_LIST (ERROR_TYPE)
 
const Error * CreateErrorPtr (MAXON_SOURCE_LOCATION_DECLARATION, ERROR_TYPE type) __attribute__((pure
 
ThreadReferencedError CreateError (MAXON_SOURCE_LOCATION_DECLARATION, ERROR_TYPE type)
 
const Error * PrivateSystemSetCurrentError (const Error &error)
 
const Error * PrivateSystemSetCurrentError (Error &&error)
 
void PrivateSetError (Error &dest, const Error *src)
 
 MAXON_MEMBERTYPE_DETECTOR (IsForwardRef, IsForwardRef, std::false_type)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE auto operator% (const ResultOk< T > &rv, ThreadReferencedError &err) -> decltype(rv.GetValue())
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINEoperator% (ResultOk< T > &&rv, ThreadReferencedError &err)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE T & operator% (ResultOk< T & > &&rv, ThreadReferencedError &err)
 
MAXON_ATTRIBUTE_FORCE_INLINE void operator% (ResultOk< void > &&rv, ThreadReferencedError &err)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE auto operator% (const ResultOk< T > &rv, maxon::details::ResultOkError &err) -> decltype(rv.GetValue())
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINEoperator% (ResultOk< T > &&rv, maxon::details::ResultOkError &err)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE T & operator% (ResultOk< T & > &&rv, maxon::details::ResultOkError &err)
 
MAXON_ATTRIBUTE_FORCE_INLINE void operator% (ResultOk< void > &&rv, maxon::details::ResultOkError &err)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE auto operator% (const Result< T > &rv, ThreadReferencedError &err) -> decltype(rv.GetValue())
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINEoperator% (Result< T > &&rv, ThreadReferencedError &err)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE T & operator% (const Result< T & > &rv, ThreadReferencedError &err)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE T & operator% (Result< T & > &&rv, ThreadReferencedError &err)
 
MAXON_ATTRIBUTE_FORCE_INLINE void operator% (const Result< void > &rv, ThreadReferencedError &err)
 
MAXON_ATTRIBUTE_FORCE_INLINE void operator% (Result< void > &&rv, ThreadReferencedError &err)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE T && operator% (ResultMemT< T > &&ptr, ThreadReferencedError &err)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE const T & operator% (const ResultMemT< T > &ptr, ThreadReferencedError &err)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE T & operator% (ResultRef< T > ptr, ThreadReferencedError &err)
 
void SetSplashMessage (const String &text)
 
void SetSplashImage (const Url &url)
 
void SetSplashStartBlocking ()
 
void SetSplashShow (Bool show)
 
static MAXON_ATTRIBUTE_FORCE_INLINE void DebugPrint (const String &str)
 
static void FreeThreadedStuff ()
 
constexpr MAXON_ATTRIBUTE_FORCE_INLINE ColorA IntToColor (UInt r, UInt g, UInt b, UInt a)
 
constexpr MAXON_ATTRIBUTE_FORCE_INLINE ColorA IntToColor (UInt r, UInt g, UInt b)
 
constexpr MAXON_ATTRIBUTE_FORCE_INLINE ColorA FloatToColor (Float r, Float g, Float b, Float a)
 
constexpr MAXON_ATTRIBUTE_FORCE_INLINE ColorA FloatToColor (Float r, Float g, Float b)
 
constexpr MAXON_ATTRIBUTE_FORCE_INLINE ColorA ColorSetAlpha (const ColorA &col, Float alpha)
 
constexpr MAXON_ATTRIBUTE_FORCE_INLINE ColorA ColorMultiplyAlpha (const ColorA &col, Float alpha)
 
constexpr MAXON_ATTRIBUTE_FORCE_INLINE Color BlendColors (const Color &col1, const Color &col2, Float alpha)
 
constexpr MAXON_ATTRIBUTE_FORCE_INLINE ColorA BlendColors (const ColorA &col1, const ColorA &col2, Float alpha)
 
template<typename COLORTYPE >
constexpr MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE BlendColor (const COLORTYPE &col1, const COLORTYPE &col2, const typename COLORTYPE::ValueType blendValue)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float GetPerceivedBrightness (const ColorA &color)
 
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsColorPerceivedAsDark (const ColorA &color)
 
 MAXON_ASSERT_STANDARD_LAYOUT (WeakRefBase)
 
 MAXON_ASSERT_STANDARD_LAYOUT (WeakRefTargetBase)
 
enum maxon::MEMORY_OBSERVER_FLAGS Int MAXON_ENUM_FLAGS (MEMORY_OBSERVER_FLAGS)
 
enum maxon::MEMORY_OBSERVER_STATE Int MAXON_ENUM_FLAGS (MEMORY_OBSERVER_STATE)
 
MAXON_ATTRIBUTE_FORCE_INLINE Error GetHResultError (HRESULT hr, MAXON_SOURCE_LOCATION_DECLARATION)
 
MAXON_ATTRIBUTE_FORCE_INLINE void operator% (HRESULT value, ThreadReferencedError &err)
 
MAXON_ATTRIBUTE_FORCE_INLINE Result< Int64PropVariantToInt64 (const PROPVARIANT &vt)
 
MAXON_ATTRIBUTE_FORCE_INLINE Result< Int64VariantToInt64 (const VARIANT &vt)
 
MAXON_ATTRIBUTE_FORCE_INLINE Result< UniversalDateTimePropVariantToUniversalDateTime (const PROPVARIANT &vt)
 
MAXON_ATTRIBUTE_FORCE_INLINE Result< UniversalDateTimeVariantToUniversalDateTime (const VARIANT &vt)
 
UniversalDateTime ConvertSystemTimeToUniversalDateTime (const SYSTEMTIME &st)
 
UInt64 FiletimeToUnixTimestamp (const FILETIME &ft)
 
static Result< UniversalDateTimeConvertFileTimeToUniversalDateTime (const FILETIME &fd, Bool filetimeIsUtc)
 
SYSTEMTIME ConvertUniversalDateTimeToSystemTime (const UniversalDateTime &dateTime)
 
FILETIME ConvertUniversalDateTimeToFileTime (const UniversalDateTime &dateTime)
 
template<>
DestructorPointer GetDestructorPointer< corenodes::FrameData > ()
 
enum maxon::BLOCK_CIPHER_MODE UInt64 MAXON_ENUM_FLAGS (BLOCK_CIPHER_MODE)
 
Result< StringGetHashString (const BaseArray< UChar > &hashValue)
 
Result< StringGetPasswordHash (const String &password, const StreamConversionFactory &hashClass, const DataDictionary &settings=DataDictionary())
 
Result< StringGetPasswordHash (const Block< const Char > &password, const StreamConversionFactory &hashClass, const DataDictionary &settings=DataDictionary())
 
Result< Tuple< String, String > > HashPasswordWithSalt (const String &password, const StreamConversionFactory &hashClass=StreamConversions::HashSHA256())
 
Result< void > AddConversionTestSetting (MAXON_SOURCE_LOCATION_DECLARATION, BaseArray< DataDictionary > &resultArray, const Id &encoderId, const Id &decoderId, Int blockSizeBits, const void *key1, Int key1BitSize, const void *key2=nullptr, Int key2BitSize=0, UInt64 flags=0, BLOCK_CIPHER_CTR_CALLBACK &&callback=BLOCK_CIPHER_CTR_CALLBACK(), const Char *srcData=nullptr, const Char *compareData=nullptr)
 
 MAXON_DECLARATION (IoHandler, ZipHandlerImplClass, "net.maxon.iohandler.zip")
 
 MAXON_ATTRIBUTE (Id, REDSHIFT_NODESPACE, "com.redshift3d.redshift4c4d.class.nodespace")
 
 MAXON_DECLARATION (Class< GlobalImportRef >, GlobalImport, "net.maxon.exchange.class.globalimport")
 
 MAXON_DECLARATION (Class< GlobalUtilsRef >, GlobalUtils, "net.maxon.exchange.class.globalutils")
 
enum maxon::WIRE_MODE UChar MAXON_ENUM_ORDERED_FLAGS (WIRE_MODE)
 
 MAXON_DATATYPE (Wires, "net.maxon.graph.wires")
 
enum maxon::CONNECTION_POSITION MAXON_ENUM_ORDERED_LIST (CONNECTION_POSITION)
 
CONNECTION_POSITION Reverse (CONNECTION_POSITION pos)
 
 MAXON_DATATYPE (GraphTransaction, "net.maxon.graph.graphtransaction")
 
 MAXON_DATATYPE (GraphNode, "net.maxon.graph.graphnode")
 
PORT_DIR GetConnectionDirection (const GraphNode &port)
 
 MAXON_ATTRIBUTE (DataDictionary, GraphNodeSelection, "net.maxon.mvp.graphnodeselection")
 
 MAXON_ATTRIBUTE (DataDictionary, GraphPortSelection, "net.maxon.mvp.graphportselection")
 
 MAXON_ATTRIBUTE (DataDictionary, GraphWireSelection, "net.maxon.mvp.graphwireselection")
 
template<typename ATTR , typename PRES , typename SEL >
static Result< void > SetGraphSelection (const GraphNode &root, const SEL &selection, SELECTION_MODE mode, const DataDictionary &userData)
 
 MAXON_ATTRIBUTE (Int, OrderIndex, "orderindex", MAXON_ATTRIBUTE_READONLY)
 
 MAXON_ATTRIBUTE (Int, InsertIndex, "insertindex", MAXON_ATTRIBUTE_READONLY)
 
 MAXON_ATTRIBUTE (Data, PortValue, "value", MAXON_ATTRIBUTE_READONLY)
 
 MAXON_ATTRIBUTE (Data, EffectivePortValue, "effectivevalue", MAXON_ATTRIBUTE_READONLY)
 
 MAXON_ATTRIBUTE (String, EffectiveName, "effectivename", MAXON_ATTRIBUTE_READONLY)
 
enum maxon::NODE_KIND MAXON_ENUM_FLAGS (NODE_KIND)
 
PORT_DIR GetPortDirection (NODE_KIND kind)
 
Bool operator== (const PathBlock &a, const NodePathInterface *b)
 
Bool operator!= (const PathBlock &a, const NodePathInterface *b)
 
Bool operator== (const NodePathInterface *b, const PathBlock &a)
 
Bool operator!= (const NodePathInterface *b, const PathBlock &a)
 
Bool operator>= (const PathBlock &a, const NodePathInterface *b)
 
Bool operator< (const PathBlock &a, const NodePathInterface *b)
 
Bool operator> (const PathBlock &a, const NodePathInterface *b)
 
Bool operator<= (const PathBlock &a, const NodePathInterface *b)
 
Result< NodePath > operator+ (const PathBlock &a, const NodePath &b)
 
 MAXON_DECLARATION (Class< AudioObjectRef >, AudioObjectClass, "net.maxon.image.class.audioobject", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
 MAXON_DATATYPE (DrawDimensionInt, "net.maxon.image.drawdimensionint", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
 MAXON_DATATYPE (DrawDimensionFloat, "net.maxon.image.drawdimensionfloat", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
 MAXON_DATATYPE (DrawRectInt, "net.maxon.image.drawrectint", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
 MAXON_DATATYPE (DrawRectFloat, "net.maxon.image.drawrectfloat", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
 MAXON_DATATYPE (DrawPoint3dInt, "net.maxon.image.drawpoint3dint", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
 MAXON_DATATYPE (DrawPoint3dFloat, "net.maxon.image.drawpoint3dfloat", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
 MAXON_DATATYPE (DrawDimension3dInt, "net.maxon.image.drawdimension3dint", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
 MAXON_DATATYPE (DrawDimension3dFloat, "net.maxon.image.drawdimension3dfloat", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
 MAXON_DATATYPE (DrawVolumeInt, "net.maxon.image.drawvolumeint", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
 MAXON_DATATYPE (DrawVolumeFloat, "net.maxon.image.drawvolumefloat", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
enum maxon::IMAGEHIERARCHY MAXON_ENUM_LIST (IMAGEHIERARCHY)
 
enum maxon::TRANSFORM_COLORS_FLAGS MAXON_ENUM_FLAGS (TRANSFORM_COLORS_FLAGS)
 
const Class< ImagePixelStorage > & GetNormalPixelStorageClass ()
 
 MAXON_REGISTRY (Class< ImageBaseRef >, ImageBaseClasses, "net.maxon.image.registry.imagebaseclasses")
 
 MAXON_REGISTRY (Class< ImageTextureRef >, ImageTextureClasses, "net.maxon.image.registry.imagetextureclasses")
 
 MAXON_REGISTRY (Class< ImageRef >, ImageClasses, "net.maxon.image.registry.imageclasses")
 
 MAXON_REGISTRY (Class< ImageLayerRef >, ImageLayerClasses, "net.maxon.image.registry.imagelayerclasses")
 
ImageRef GetImageOf (const ImageBaseRef &bmp)
 
ImageLayerRef GetFirstAlphaOf (const ImageBaseRef &bmp)
 
Result< void > ConvertImageSequence (const Url &sourceUrl, const Url &destPath, const String &destFilePatern, const Class< MediaOutputUrlRef > &exportClass, const ValueReceiver< const Url & > &resultFiles)
 
Result< void > CopyImageData (const ImageBaseRef &source, const ImageRef &dest, Bool allowDifferentSize)
 
 MAXON_DATATYPE (BITS, "net.maxon.image.bits", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
enum maxon::COLORPROFILEINFO MAXON_ENUM_LIST (COLORPROFILEINFO)
 
enum maxon::COLORCONVERSIONINTENT MAXON_ENUM_LIST (COLORCONVERSIONINTENT)
 
enum maxon::COLORCONVERSIONFLAGS MAXON_ENUM_FLAGS (COLORCONVERSIONFLAGS)
 
template<typename T >
SRGBtoLinear (const T &v)
 
template<typename T >
LinearToSRGB (const T &v)
 
 MAXON_REGISTRY (ColorProfile, ColorProfiles, "net.maxon.image.registry.colorprofiles")
 
 MAXON_REGISTRY (ColorSpace, ColorSpaces, "net.maxon.image.registry.colorspaces")
 
 MAXON_REGISTRY (ImageChannelType, ImageChannelTypes, "net.maxon.image.registry.imagechanneltypes")
 
enum maxon::BLENDPIXELFLAGS MAXON_ENUM_FLAGS (BLENDPIXELFLAGS)
 
 MAXON_DATATYPE (BlendPixelHandlerRef, "net.maxon.datatype.blendpixelhandlerref", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
 MAXON_REGISTRY (ImagePixelBlend, ImagePixelBlends, "net.maxon.render.registry.blendmodeclasses")
 
enum maxon::CONVERTPIXELFLAGS MAXON_ENUM_FLAGS (CONVERTPIXELFLAGS)
 
enum maxon::GETPIXELHANDLERFLAGS MAXON_ENUM_FLAGS (GETPIXELHANDLERFLAGS)
 
enum maxon::GETPIXELFLAGS MAXON_ENUM_FLAGS (GETPIXELFLAGS)
 
enum maxon::SETPIXELHANDLERFLAGS MAXON_ENUM_FLAGS (SETPIXELHANDLERFLAGS)
 
enum maxon::SETPIXELFLAGS MAXON_ENUM_FLAGS (SETPIXELFLAGS)
 
Result< CONVERTPIXELFUNCLambdaWrapper (CONVERTPIXELFUNCSTATIC func, const ChannelOffsets &dstChannelOffsets, const ChannelOffsets &srcChannelOffsets)
 
 MAXON_DECLARATION (Class< PixelFormat >, PixelFormatBaseClass, "net.maxon.image.class.pixelformatbase", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
Result< PixelFormat > JoinPixelFormats (const PixelFormat &format1, const PixelFormat &format2)
 
 MAXON_REGISTRY (PixelFormatGroup, PixelFormats, "net.maxon.image.registry.pixelformats")
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8u &dst, const Pix8u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8u &dst, const Pix8s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8u &dst, const Pix16u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8u &dst, const Pix16s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8u &dst, const Pix32u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8u &dst, const Pix32s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8u &dst, const Pix32f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8u &dst, const Pix64f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16u &dst, const Pix8u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16u &dst, const Pix8s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16u &dst, const Pix16u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16u &dst, const Pix16s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16u &dst, const Pix32u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16u &dst, const Pix32s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16u &dst, const Pix32f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16u &dst, const Pix64f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32u &dst, const Pix8u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32u &dst, const Pix8s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32u &dst, const Pix16u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32u &dst, const Pix16s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32u &dst, const Pix32u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32u &dst, const Pix32s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32u &dst, const Pix32f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32u &dst, const Pix64f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8s &dst, const Pix8u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8s &dst, const Pix8s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8s &dst, const Pix16u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8s &dst, const Pix16s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8s &dst, const Pix32u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8s &dst, const Pix32s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8s &dst, const Pix32f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix8s &dst, const Pix64f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16s &dst, const Pix8u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16s &dst, const Pix8s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16s &dst, const Pix16u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16s &dst, const Pix16s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16s &dst, const Pix32u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16s &dst, const Pix32s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16s &dst, const Pix32f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16s &dst, const Pix64f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32s &dst, const Pix8u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32s &dst, const Pix8s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32s &dst, const Pix16u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32s &dst, const Pix16s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32s &dst, const Pix32u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32s &dst, const Pix32s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32s &dst, const Pix32f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32s &dst, const Pix64f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Float32 &dst, const Pix8u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Float64 &dst, const Pix8u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32f &dst, const Pix16u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32f &dst, const Pix32u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32f &dst, const Pix32s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32f &dst, const Pix32f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix32f &dst, const Pix64f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix64f &dst, const Pix16u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix64f &dst, const Pix32u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix64f &dst, const Pix32s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix64f &dst, const Pix32f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix64f &dst, const Pix64f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16f &dst, const Pix8u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16f &dst, const Pix16u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16f &dst, const Pix32u src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16f &dst, const Pix32s src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16f &dst, const Pix16f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16f &dst, const Pix32f src)
 
MAXON_ATTRIBUTE_FORCE_INLINE void ConvertPixel (Pix16f &dst, const Pix64f src)
 
template<typename PIXELDEPTH >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsPixelIdentical (PIXELDEPTH a, PIXELDEPTH b, PIXELDEPTH oneTolerance)
 
MAXON_ATTRIBUTE_FORCE_INLINE PixelFormat GetNativeFloatColorAlphaFormat ()
 
MAXON_ATTRIBUTE_FORCE_INLINE PixelFormat GetNativeFloatColorFormat ()
 
 MAXON_REGISTRY (Class< ImagePixelStorage >, ImagePixelStorageClasses, "net.maxon.image.registry.imagepixelstorageclasses")
 
 MAXON_DATATYPE (UpdateRegion, "net.maxon.image.updateregion", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
 MAXON_REGISTRY (Class< VectorImageRef >, VectorImageClasses, "net.maxon.image.registry.vectorimageclasses")
 
 MAXON_DECLARATION (Class< ImageRegionTilesObserverRef >, ImageRegionSingleTileObserverClass, "net.maxon.class.imageregionobserver.tiles", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
enum maxon::LAYERSETMODE MAXON_ENUM_LIST (LAYERSETMODE)
 
 MAXON_DECLARATION (Class< MediaStreamAudioDataExportRef >, MediaStreamAudioDataExportClass, "net.maxon.image.class.mediastreamaudiodataexport", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
template<typename REFTYPE >
static Result< BoolMediaTraverseChildren (const REFTYPE &t, const ConstDataPtr &branch, const Delegate< Result< Bool >(const REFTYPE &child, const REFTYPE &parent, const ConstDataPtr &branch, Int depth)> &func, Int depth=0)
 
template<typename REFTYPE >
static Result< BoolMediaTraverseMeAndChildren (const REFTYPE &t, const REFTYPE &parent, const ConstDataPtr &branch, const Delegate< Result< Bool >(const REFTYPE &child, const REFTYPE &parent, const ConstDataPtr &branch, Int depth)> &func, Int depth=0)
 
enum maxon::MEDIAFORMATTYPE MAXON_ENUM_LIST (MEDIAFORMATTYPE)
 
enum maxon::MEDIAALPHATYPE MAXON_ENUM_LIST (MEDIAALPHATYPE)
 
 MAXON_DECLARATION (Class< MediaBaseRef >, MediaBaseClass, "net.maxon.image.class.mediabase", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
 MAXON_DECLARATION (Class< MediaConverterRef >, MediaConverterBaseClass, "net.maxon.image.class.mediaconverterbase", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
 MAXON_DECLARATION (Class< FileFormat >, FileFormatImageBaseClass, "net.maxon.image.class.fileformatimagebase", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
 MAXON_REGISTRY (Class< MediaOutputUrlRef >, ImageSaverClasses, "net.maxon.image.registry.imagesaverclasses")
 
enum maxon::RLACHANNELS MAXON_ENUM_LIST (RLACHANNELS)
 
enum maxon::RLAFLAGS MAXON_ENUM_FLAGS (RLAFLAGS)
 
Char GetRlaRpfChannelSymbol (RLACHANNELS channel)
 
Int GetRlaRpfChannelSize (RLACHANNELS channel)
 
Tuple< ImageChannel, ImageChannel, ImageChannel > GetRlaRpfChannelType (RLACHANNELS channel)
 
Int64 ToWindowsTime (const TimeValue &time)
 
TimeValue ToMaxonTime (Int64 time)
 
Vec2< IntFpsToInt (Float fps)
 
enum maxon::SELECTIONHANDLERRESULT MAXON_ENUM_FLAGS (SELECTIONHANDLERRESULT)
 
 MAXON_DECLARATION (Class< MediaOutputRef >, MediaOutputBaseClass, "net.maxon.image.class.mediaoutputbase", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
 MAXON_DECLARATION (Class< MediaOutputTextureRef >, MediaOutputTextureClass, "net.maxon.image.class.mediaoutputtexture", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
 MAXON_DECLARATION (Class< MediaOutputUrlRef >, MediaOutputUrlBaseClass, "net.maxon.image.class.mediaoutputurlbase", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
Result< MediaSessionRef > MediaSessionImport (const Url &fileName, const TimeValue &targetTime, MEDIASESSIONFLAGS flags, const MediaOutputRef &outputConverter, const MediaOutputSelectionHandler &selectionHandler, const MediaSessionProgressCallback &progressCallback, const FileFormatHandler &preferredHandler, const ValueReceiver< const FileFormatHandler & > &fileFormats={})
 
enum maxon::MEDIASESSIONFLAGS MAXON_ENUM_FLAGS (MEDIASESSIONFLAGS)
 
 MAXON_DECLARATION (Class< MediaSessionRef >, MediaSessionObject, "net.maxon.image.class.mediasessionobject", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
 MAXON_DECLARATION (Class< MediaStreamRef >, MediaStreamBaseClass, "net.maxon.image.class.mediastreambase", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
 MAXON_DECLARATION (Class< MediaStreamExifDataRef >, MediaStreamExifDataClass, "net.maxon.image.class.mediastreamexifdata", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
 MAXON_DECLARATION (Class< MediaStreamImageBaseRef >, MediaStreamImageBaseClass, "net.maxon.image.class.mediastreamimagebase", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
 MAXON_DECLARATION (Class< MediaStreamImageDataImportRef >, MediaStreamImageDataImportClass, "net.maxon.image.class.mediastreamimagedataimport", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
 MAXON_DECLARATION (Class< MediaStreamImageDataExportRef >, MediaStreamImageDataExportClass, "net.maxon.image.class.mediastreamimagedataexport", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
 MAXON_DECLARATION (Class< MediaStreamAudioDataImportRef >, MediaStreamAudioDataImportClass, "net.maxon.image.class.mediastreamaudiodataimport", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
 MAXON_DECLARATION (Class< MediaStreamImageDataForwardImportRef >, MediaStreamForwardImageDataStreamsImportClass, "net.maxon.image.class.mediastreamforwardimagedatastreamsimport", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
Result< DataGetSelectedFormatPreferAspectRatio_1_1 (const MediaStreamRef &stream, MediaStreamFormat &resFormat)
 
 MAXON_DECLARATION (Class< MediaStreamFormat >, MediaStreamFormatClass, "net.maxon.image.class.mediastreamformat", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
 MAXON_DECLARATION (Class< MediaStreamProperties >, MediaStreamPropertiesClass, "net.maxon.image.class.mediastreamproperties", MAXON_IMPLEMENTATION_MODULE("net.maxon.image"))
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendOver (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendAverage (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendMultiply (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendScreen (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendSubtract (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendDivide (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendAdd (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendOverlay (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendHardLight (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendSoftLight (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendDarken (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendLighten (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendPinLight (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendDifference (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendExclusion (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendNegative (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendStamp (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendXor (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendGlow (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendReflect (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendHeat (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendFreeze (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendHypot (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE Dissolve (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendHardMix (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendColorDodge (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendColorBurn (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendLinearDodge (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendLinearBurn (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE BlendVividLight (FLOATTYPE background, FLOATTYPE foreground)
 
template<typename COLORTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE BlendHue (const COLORTYPE &background, const COLORTYPE &foreground)
 
template<typename COLORTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE BlendSaturation (const COLORTYPE &background, const COLORTYPE &foreground)
 
template<typename COLORTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE BlendLuminance (const COLORTYPE &background, const COLORTYPE &foreground)
 
template<typename COLORTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE BlendColor (const COLORTYPE &background, const COLORTYPE &foreground)
 
template<typename COLORTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE BlendLevr (const COLORTYPE &background, const COLORTYPE &foreground)
 
template<typename COLORTYPE >
static MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE::ValueType LuminanceColor (const COLORTYPE &color)
 
template<typename COLORATYPE >
static MAXON_ATTRIBUTE_FORCE_INLINE COLORATYPE::ValueType LuminanceColorA (const COLORATYPE &color)
 
template<typename COLORTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE BlendDarker (const COLORTYPE &background, const COLORTYPE &foreground)
 
template<typename COLORTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE BlendLighter (const COLORTYPE &background, const COLORTYPE &foreground)
 
enum maxon::BLEND_MODES MAXON_ENUM_LIST (BLEND_MODES)
 
template<BLEND_MODES MODE, typename COLORATYPE >
static MAXON_ATTRIBUTE_FORCE_INLINE COLORATYPE BlendRGBA (const COLORATYPE &background, const COLORATYPE &foreground, typename COLORATYPE::ValueType opacity)
 
MAXON_ATTRIBUTE_FORCE_INLINE Color XyzToRgb (const Color &xyz)
 
MAXON_ATTRIBUTE_FORCE_INLINE Color RgbToXyz (const Color &rgb)
 
MAXON_ATTRIBUTE_FORCE_INLINE Color RgbToCmy (const Color rgb)
 
MAXON_ATTRIBUTE_FORCE_INLINE Color CmyToRgb (const Color cmy)
 
template<typename COLORTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE RgbToHsv (const COLORTYPE &rgb)
 
template<typename COLORTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE HsvToRgb (const COLORTYPE &hsv)
 
template<typename COLORTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE RgbToHsl (const COLORTYPE &rgb)
 
template<typename FLOATTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE Value (FLOATTYPE nl, FLOATTYPE n2, FLOATTYPE hue)
 
template<typename COLORTYPE >
MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE HslToRgb (const COLORTYPE &hsl)
 
MAXON_ATTRIBUTE_FORCE_INLINE Color ColorTemperatureToRGB (Float temperature)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE enable_if_float< T > Fract (T value)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE enable_if_float< T > Invert (T value)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE enable_if_scalar< T > ClampValueCustom (T value, T lowerLimit, T upperLimit)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE enable_if_scalar< T > MinCustom (T a, T b)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE enable_if_scalar< T > MaxCustom (T a, T b)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE enable_if_scalar< T > SignNoTemplate (T value)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE enable_if_integral< T > FMod (T a, T b)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE enable_if_scalar< T > MapRange (T input, T inputMin, T inputMax, T outputMin, T outputMax)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE enable_if_float< T > Step (T value, T threshold)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE enable_if_float< T > Quantize (T value, T steps)
 
template<typename T >
MAXON_ATTRIBUTE_FORCE_INLINE enable_if_float< T > Cbrt (T input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 SquaredLength (const Vector2d32 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 SquaredLength (const Vector2d64 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 SquaredLength (const Vector32 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 SquaredLength (const Vector64 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 SquaredLength (const Vector4d32 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 SquaredLength (const Vector4d64 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 SquaredLength (const Color32 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 SquaredLength (const Color64 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 SquaredLength (const ColorA32 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 SquaredLength (const ColorA64 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Length (const Vector2d32 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Length (const Vector2d64 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Length (const Vector32 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Length (const Vector64 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Length (const Vector4d32 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Length (const Vector4d64 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Length (const Color32 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Length (const Color64 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 Length (const ColorA32 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 Length (const ColorA64 &input)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 SafePow (Float64 v1, Float64 v2)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 SafePow (Float32 v1, Float32 v2)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float64 SafeSqrt (Float64 v)
 
MAXON_ATTRIBUTE_FORCE_INLINE Float32 SafeSqrt (Float32 v)
 
 MATH_HELPER_INSTANTIATE (Clamp01)
 
 MATH_HELPER_INSTANTIATE (ATan2)
 
 MATH_HELPER_INSTANTIATE (Exp)
 
 MATH_HELPER_INSTANTIATE (Exp2)
 
 MATH_HELPER_INSTANTIATE (Ln)
 
 MATH_HELPER_INSTANTIATE (Log10)
 
 MATH_HELPER_INSTANTIATE (Log2)
 
 MATH_HELPER_INSTANTIATE (Gamma)
 
 MATH_HELPER_INSTANTIATE (Si)
 
 MATH_HELPER_INSTANTIATE (Sinc)
 
 MATH_HELPER_INSTANTIATE (Abs)
 
 MATH_HELPER_INSTANTIATE (Ceil)
 
 MATH_HELPER_INSTANTIATE (Floor)
 
 MATH_HELPER_INSTANTIATE (Round)
 
 MATH_HELPER_INSTANTIATE (ClampValueCustom)
 
 MATH_HELPER_INSTANTIATE (MinCustom)
 
 MATH_HELPER_INSTANTIATE (MaxCustom)
 
 MATH_HELPER_INSTANTIATE (Fract)
 
 MATH_HELPER_INSTANTIATE (Invert)
 
 MATH_HELPER_INSTANTIATE (FMod)
 
 MATH_HELPER_INSTANTIATE (MapRange)
 
 MATH_HELPER_INSTANTIATE (Inverse)
 
 MATH_HELPER_INSTANTIATE (SignNoTemplate)
 
 MATH_HELPER_INSTANTIATE (SmoothStep)
 
 MATH_HELPER_INSTANTIATE (BoxStep)
 
 MATH_HELPER_INSTANTIATE (Step)
 
 MATH_HELPER_INSTANTIATE (Quantize)
 
 MATH_HELPER_INSTANTIATE (Pow)
 
 MATH_HELPER_INSTANTIATE (Sqrt)
 
 MATH_HELPER_INSTANTIATE (Cbrt)
 
 MATH_HELPER_INSTANTIATE (Sin)
 
 MATH_HELPER_INSTANTIATE (Cos)
 
 MATH_HELPER_INSTANTIATE (Tan)
 
 MATH_HELPER_INSTANTIATE (Sinh)
 
 MATH_HELPER_INSTANTIATE (Cosh)
 
 MATH_HELPER_INSTANTIATE (Tanh)
 
 MATH_HELPER_INSTANTIATE (ASin)
 
 MATH_HELPER_INSTANTIATE (ACos)
 
 MATH_HELPER_INSTANTIATE (ATan)
 
 MATH_HELPER_INSTANTIATE (SafePow)
 
 MATH_HELPER_INSTANTIATE (SafeSqrt)
 
enum maxon::ANIMBLENDSTATE MAXON_ENUM_LIST (ANIMBLENDSTATE)
 
 MAXON_DECLARATION (Class< BlendAnimationRef >, AnimBlendClass, "net.maxon.class.blendanimationref", MAXON_IMPLEMENTATION_MODULE("net.maxon.math"))
 
 MAXON_REGISTRY (BlendFunctionRef, BlendFunctions, "net.maxon.registry.blendfunction")
 
template<typename T >
static T ComplexGetReal (const Complex< T > &val)
 
template<typename T >
static T ComplexGetReal (const T &val)
 
template<typename T >
static T ComplexGetImag (const Complex< T > &val)
 
template<typename T >
static T ComplexGetImag (const T &val)
 
template<typename T1 , typename T2 >
static void ComplexSetReal (Complex< T1 > &dst, const T2 &val)
 
template<typename T1 , typename T2 >
static void ComplexSetReal (T1 &dst, const T2 &val)
 
template<typename T1 , typename T2 >
static void ComplexSetImag (Complex< T1 > &dst, const T2 &val)
 
template<typename T1 , typename T2 >
static void ComplexSetImag (T1 &dst, const T2 &val)
 
 MAXON_DATATYPE (Complex32, "net.maxon.datatype.complex32")
 
 MAXON_DATATYPE (Complex64, "net.maxon.datatype.complex64")
 
enum maxon::FFT_FLAGS MAXON_ENUM_FLAGS (FFT_FLAGS)
 
enum maxon::FFT_SUPPORT MAXON_ENUM_FLAGS (FFT_SUPPORT)
 
 MAXON_REGISTRY (Class< FFTRef >, FFTClasses, "net.maxon.registry.fftclasses")
 
enum maxon::GRADIENT_INTERPOLATION_TYPE MAXON_ENUM_ORDERED_LIST (GRADIENT_INTERPOLATION_TYPE)
 
 MAXON_DATATYPE (GradientKnot, "net.maxon.datatype.gradientknot")
 
COMPARERESULT Compare (const GradientKnot &a, const GradientKnot &b)
 
 MAXON_DATATYPE (MatrixNxM32, "net.maxon.datatype.matrixnxm32")
 
 MAXON_DATATYPE (MatrixNxM64, "net.maxon.datatype.matrixnxm64")
 
 MAXON_DATATYPE (MatrixNxMComplex32, "net.maxon.datatype.matrixnxmcomplex32")
 
 MAXON_DATATYPE (MatrixNxMComplex64, "net.maxon.datatype.matrixnxmcomplex64")
 
ROTATIONORDER TranslateRotationOrder (const Id &type)
 
 MAXON_DATATYPE (PRSMatrix64, "net.maxon.neutron.datatype.psrmatrix")
 
 MAXON_DATATYPE (PRSMatrix32, "net.maxon.math.datatype.prsmatrix32")
 
 MAXON_REGISTRY (Class< RenderNoise >, RenderNoiseClasses, "net.maxon.render.registry.rendernoiseclasses")
 
enum maxon::NURBSCURVE_CONTINUITY MAXON_ENUM_LIST (NURBSCURVE_CONTINUITY)
 
template<Int D>
 MAXON_IMPLEMENTATION_SIMPLE_REGISTER (NURBSCurveWithContinuity< D >)
 
enum maxon::NURBSCURVE_KNOTMODE MAXON_ENUM_LIST (NURBSCURVE_KNOTMODE)
 
template<Int D>
 MAXON_IMPLEMENTATION_SIMPLE_REGISTER (NURBSCurve< D >)
 
 MAXON_DATATYPE (Quaternion32, "net.maxon.datatype.quaternion32")
 
 MAXON_DATATYPE (Quaternion64, "net.maxon.datatype.quaternion64")
 
enum maxon::SPLINEMAPPER_KNOT_INTERPOLATION_TYPE MAXON_ENUM_ORDERED_LIST (SPLINEMAPPER_KNOT_INTERPOLATION_TYPE)
 
enum maxon::SPLINEMAPPER_KNOT_FLAGS Int MAXON_ENUM_FLAGS (SPLINEMAPPER_KNOT_FLAGS)
 
 MAXON_DATATYPE (SplineMapperKnot, "net.maxon.datatype.splinemapperknot")
 
enum maxon::SPLINEMAPPER_SPLINE_TYPE MAXON_ENUM_ORDERED_LIST (SPLINEMAPPER_SPLINE_TYPE)
 
enum maxon::SPLINEMAPPER_RANGE_STATE MAXON_ENUM_ORDERED_LIST (SPLINEMAPPER_RANGE_STATE)
 
void MatrixConvert (SquareMatrix4d &dest, const Matrix &src)
 
enum maxon::PRIMITIVETYPE MAXON_ENUM_LIST (PRIMITIVETYPE)
 
 MAXON_DECLARATION (Class< DistanceQueryRef >, DistanceCalculator, "net.maxon.geom.interface.distancequery.distancecalculator")
 
 MAXON_REGISTRY (CustomDataTagClass, CustomDataTagClasses, "net.maxon.mesh_misc.registry.customdatatagclasses")
 
 MAXON_REGISTRY (Class< CustomDataTagDisplayRef >, CustomDataTagDisplayClasses, "net.maxon.mesh_misc.registry.customdatatagdisplayclasses")
 
 MAXON_DATATYPE (MeshAttribute, "net.maxon.mesh_misc.datatype.meshattribute")
 
 MAXON_DATATYPE (PolygroupInformation, "net.maxon.meshattribute.gozpolyinformation")
 
 MAXON_MESHATTRIBUTE (PolygroupInformation, POLYGROUP)
 
 MAXON_DATATYPE (POLYGROUP_MESHATTRIBUTE, "net.maxon.meshattribute.gozpolygroup")
 
 MAXON_DECLARATION (Class< VoxelizationRef >, PolyVoxelization, "net.maxon.geom.interface.voxelization.polyvoxelization")
 
enum maxon::METRICUNIT MAXON_ENUM_LIST (METRICUNIT)
 
enum maxon::ANGLEUNIT MAXON_ENUM_LIST (ANGLEUNIT)
 
enum maxon::CORENODE_PORT_FLAGS MAXON_ENUM_FLAGS (CORENODE_PORT_FLAGS)
 
enum maxon::PORT_DIR Int MAXON_ENUM_LIST (PORT_DIR)
 
PORT_DIRoperator++ (PORT_DIR &dir)
 
PORT_DIR Reverse (PORT_DIR dir)
 
 MAXON_REGISTRY (IconProvider, IconProviders, "net.maxon.registry.iconproviders")
 
Result< UrlGetUrlFromIconProviders (const CString &iconId)
 
enum maxon::IOFORMAT MAXON_ENUM_LIST (IOFORMAT)
 
template<typename T >
std::enable_if< GetCollectionKind< T >::value==COLLECTION_KIND::ARRAY, Result< void > >::type ReadDocument (const Url &url, const Id &id, T &object, const DataDictionary &dict=DataDictionary())
 
template<typename T >
std::enable_if< GetCollectionKind< T >::value !=COLLECTION_KIND::ARRAY &&!STD_IS_REPLACEMENT(same, T, Data), Result< void > >::type ReadDocument (const Url &url, const Id &id, T &object, const DataDictionary &dict=DataDictionary())
 
template<typename T >
std::enable_if< STD_IS_REPLACEMENT(same, T, Data), Result< void > >::type ReadDocument (const Url &url, const Id &id, T &object, const DataDictionary &dict=DataDictionary())
 
template<typename T >
std::enable_if< GetCollectionKind< T >::value==COLLECTION_KIND::ARRAY, Result< void > >::type ReadDocument (UrlOrInputStream &&urlOrStream, const Id &id, T &object, IOFORMAT format=IOFORMAT::DEFAULT, const DataDictionary &dict=DataDictionary())
 
template<typename T >
std::enable_if< GetCollectionKind< T >::value !=COLLECTION_KIND::ARRAY &&!STD_IS_REPLACEMENT(same, T, Data), Result< void > >::type ReadDocument (UrlOrInputStream &&urlOrStream, const Id &id, T &object, IOFORMAT format=IOFORMAT::DEFAULT, const DataDictionary &dict=DataDictionary())
 
template<typename T >
std::enable_if< STD_IS_REPLACEMENT(same, T, Data), Result< void > >::type ReadDocument (UrlOrInputStream &&urlOrStream, const Id &id, T &object, IOFORMAT format=IOFORMAT::DEFAULT, const DataDictionary &dict=DataDictionary())
 
template<typename T >
Result< void > WriteDocument (const Url &url, OPENSTREAMFLAGS flags, const Id &id, const T &object, IOFORMAT format=IOFORMAT::DEFAULT, const DataDictionary &dict=DataDictionary())
 
template<typename T >
std::enable_if< GetCollectionKind< T >::value==COLLECTION_KIND::ARRAY, Result< void > >::type WriteDocument (const OutputStreamRef &stream, const Id &id, const T &object, IOFORMAT format=IOFORMAT::DEFAULT, const DataDictionary &dict=DataDictionary())
 
template<typename T >
std::enable_if< STD_IS_REPLACEMENT(same, T, Data), Result< void > >::type WriteDocument (const OutputStreamRef &stream, const Id &id, const T &object, IOFORMAT format=IOFORMAT::DEFAULT, const DataDictionary &dict=DataDictionary())
 
template<typename T >
std::enable_if< GetCollectionKind< T >::value !=COLLECTION_KIND::ARRAY &&!STD_IS_REPLACEMENT(same, T, Data), Result< void > >::type WriteDocument (const OutputStreamRef &stream, const Id &id, const T &object, IOFORMAT format=IOFORMAT::DEFAULT, const DataDictionary &dict=DataDictionary())
 
enum maxon::PROFILER_POINT_TYPE MAXON_ENUM_LIST (PROFILER_POINT_TYPE)
 
enum maxon::PROFILER_STATE MAXON_ENUM_LIST (PROFILER_STATE)
 
enum maxon::PROFILER_CLOCK_MODE MAXON_ENUM_LIST (PROFILER_CLOCK_MODE)
 
 MAXON_DECLARATION (maxon::Profiler *, ProfilerInstance, "net.maxon.profiler")
 
 MAXON_ATTRIBUTE (UniversalDateTime, DATE_FILECREATED, "net.maxon.ramdisk.date.created")
 
 MAXON_ATTRIBUTE (UniversalDateTime, DATE_FILEMODIFIED, "net.maxon.ramdisk.date.modified")
 
 MAXON_ATTRIBUTE (UniversalDateTime, DATE_FILEACCESSED, "net.maxon.ramdisk.date.accessed")
 
template<typename TYPE >
ReferenceWrapper< TYPE > Ref (TYPE &val) noexcept
 
template<typename TYPE >
void Ref (TYPE &&val)=delete
 
template<typename TYPE >
ReferenceWrapper< const TYPE > CRef (TYPE &val) noexcept
 
template<typename TYPE >
void CRef (TYPE &&val)=delete
 
enum maxon::SELECTION_MODE UChar MAXON_ENUM_LIST (SELECTION_MODE)
 
enum maxon::SELECTION_STATUS UChar MAXON_ENUM_FLAGS (SELECTION_STATUS)
 
 MAXON_DATATYPE (SourceControlChangeEntry, "net.maxon.sourcecontrolchangeentry")
 
Result< void > SCCCheckOutFile (const Url &url, Bool outputError)
 
Result< void > SCCAddFile (const Url &url, Bool outputError)
 
 MAXON_REGISTRY (Class< SqlDatabaseRef >, SqlDatabaseClasses, "net.maxon.registry.sqldatabaseclasses")
 
enum maxon::REGPARSEMODE MAXON_ENUM_LIST (REGPARSEMODE)
 
 MAXON_REGISTRY (SubData, SubDatas, "net.maxon.registry.subdatas")
 
 MAXON_REGISTRY (SubDataOperation, SubDataOperations, "net.maxon.registry.subdataoperations")
 
 MAXON_REGISTRY (Class< UnitTestRef >, UnitTestClasses, "net.maxon.registry.unittestclasses")
 
 MAXON_REGISTRY (Class< UnitTestRef >, UnitTestWithC4DPluginClasses, "net.maxon.registry.unittestwithc4dpluginclasses")
 
 MAXON_REGISTRY (Class< UnitTestRef >, SpeedTestClasses, "net.maxon.registry.speedtestclasses")
 
 MAXON_REGISTRY (Class< UnitTestRef >, LongRunTestClasses, "net.maxon.registry.longruntestclasses")
 
 MAXON_DECLARATION (Class< UnitTestRef >, UnitTestBaseClass, "net.maxon.class.unittestbase", MAXON_IMPLEMENTATION_MODULE("net.maxon.misc"))
 
 MAXON_REGISTRY (Class< ConvexDecompositionRef >, ConvexDecompositionClasses, "net.maxon.registry.convexdecompositionclasses")
 
template<typename T , typename U = T, typename = std::enable_if_t<STD_IS_REPLACEMENT(arithmetic, T)>>
constexpr MAXON_ATTRIBUTE_FORCE_INLINEClampQuadIndex (const T index)
 
Int32 FindDirectedVertexIndexInQuad (const Block< const Int32 > polyVertices, const EdgePair edgePair)
 
EdgePair FindPrevEdgeInQuad (const Block< const Int32 > polyVertices, const EdgePair edgePair)
 
EdgePair FindNextEdgeInQuad (const Block< const Int32 > polyVertices, const EdgePair edgePair)
 
EdgePair FindOppositeDirectedEdgeInQuad (const Block< const Int32 > polyVertices, const EdgePair edgePair)
 
enum maxon::GEOMETRY_TEST_EXACT MAXON_ENUM_LIST (GEOMETRY_TEST_EXACT)
 
enum maxon::LOOP_OVERLAP_STATE MAXON_ENUM_LIST (LOOP_OVERLAP_STATE)
 
 MAXON_REGISTRY (InterpolateType, InterpolateTypes, "net.maxon.geometry.registry.interpolation.types")
 
 MAXON_DATATYPE (SimplePolygon, "net.maxon.geom.simplepolygon")
 
 MAXON_DATATYPE (UVWPolygon, "net.maxon.geom.uvwpolygon")
 
template<typename INDEXTYPE , typename COUNT >
INDEXTYPE GetPredecessor (INDEXTYPE index, COUNT vertexCount)
 
template<typename INDEXTYPE , typename COUNT >
INDEXTYPE GetSuccessor (INDEXTYPE index, COUNT vertexCount)
 
enum maxon::HTTPCODE MAXON_ENUM_LIST (HTTPCODE)
 
enum maxon::SOCKETMODE MAXON_ENUM_LIST (SOCKETMODE)
 
enum maxon::CONNECTIONMODE MAXON_ENUM_LIST (CONNECTIONMODE)
 
enum maxon::CONNECTIONTYPE MAXON_ENUM_LIST (CONNECTIONTYPE)
 
 MAXON_DECLARATION_STRINGENCODING ("html", Html, MAXON_IMPLEMENTATION_MODULE("net.maxon.network"))
 
 MAXON_DECLARATION_STRINGENCODING ("punycode", Punycode, MAXON_IMPLEMENTATION_MODULE("net.maxon.network"))
 
enum maxon::PROTOCOL MAXON_ENUM_LIST (PROTOCOL)
 
enum maxon::WILDCARD_IPV4_ADDRESS_TYPE MAXON_ENUM_LIST (WILDCARD_IPV4_ADDRESS_TYPE)
 
enum maxon::WILDCARD_IPV6_ADDRESS_TYPE MAXON_ENUM_LIST (WILDCARD_IPV6_ADDRESS_TYPE)
 
 MAXON_DECLARATION (Class< SSHNetworkConnectionRef >, NetworkConnectionSSHClass, "net.maxon.class.networkconnectionssh")
 
enum maxon::SSLSOCKETTYPE MAXON_ENUM_LIST (SSLSOCKETTYPE)
 
enum maxon::SSLPROTOCOLVERSION MAXON_ENUM_LIST (SSLPROTOCOLVERSION)
 
enum maxon::SSLCERTREQUIREMENTS MAXON_ENUM_FLAGS (SSLCERTREQUIREMENTS)
 
enum maxon::SSLFILETYPE MAXON_ENUM_LIST (SSLFILETYPE)
 
 MAXON_DECLARATION (Class< SSLNetworkConnectionRef >, NetworkConnectionSSLClass, "net.maxon.class.networkconnectionssl")
 
enum maxon::OAUTHSIGNATUREMETHOD MAXON_ENUM_LIST (OAUTHSIGNATUREMETHOD)
 
enum maxon::OAUTHHTTPMETHOD MAXON_ENUM_LIST (OAUTHHTTPMETHOD)
 
enum maxon::OAUTHERRORCODE MAXON_ENUM_LIST (OAUTHERRORCODE)
 
 MAXON_DECLARATION (Class< UrlRedirectRef >, UrlRedirectClass, "net.maxon.class.urlredirectclass")
 
Bool operator== (const ResourceIdentifier &lhs, const ResourceIdentifier &rhs)
 
Bool operator!= (const ResourceIdentifier &lhs, const ResourceIdentifier &rhs)
 
Bool operator== (const ServiceProviderDetails &lhs, const ServiceProviderDetails &rhs)
 
Bool operator!= (const ServiceProviderDetails &lhs, const ServiceProviderDetails &rhs)
 
enum maxon::MEDIA MAXON_ENUM_LIST (MEDIA)
 
enum maxon::MEDIASUB MAXON_ENUM_LIST (MEDIASUB)
 
enum maxon::SMTPRECEIVERFIELD UChar MAXON_ENUM_LIST (SMTPRECEIVERFIELD)
 
enum maxon::HTTPMETHOD MAXON_ENUM_LIST (HTTPMETHOD)
 
CString ConvertFromUnicodeToUtf8Url (const StringEncodingRef &urlEncoding, const String &src)
 
 MAXON_DECLARATION (ComponentDescriptor, CombinerHttpCodeComponents, "net.maxon.component.combinerhttpcodecomponents")
 
enum maxon::HTTPREQUESTTYPE MAXON_ENUM_LIST (HTTPREQUESTTYPE)
 
 MAXON_DECLARATION (Class< NetworkIpHandlerRef >, NetworkIpHandlerClass, "net.maxon.class.networkiphandler")
 
 MAXON_DECLARATION (Class< NetworkHttpHandlerRef >, NetworkHttpHandlerClass, "net.maxon.class.networkhttphandler")
 
 MAXON_DECLARATION (Class< NetworkWebServerRef >, NetworkWebServerClass, "net.maxon.class.networkwebserver")
 
enum maxon::WEBSOCKETSTATE MAXON_ENUM_LIST (WEBSOCKETSTATE)
 
enum maxon::WEBSOCKETTYPE MAXON_ENUM_LIST (WEBSOCKETTYPE)
 
enum maxon::WEBSOCKET_OPCODE UChar MAXON_ENUM_LIST (WEBSOCKET_OPCODE)
 
 MAXON_DECLARATION (Class< NetworkWebSocketConnectionRef >, NetworkWebSocketConnectionClass, "net.maxon.class.networkwebsocketconnection")
 
 MAXON_DECLARATION (Class< NetworkWebSocketSignalRef >, NetworkWebSocketSignalClass, "net.maxon.class.networkwebsocketsignal")
 
 MAXON_DECLARATION (Class< NetworkWebSocketServerRef >, NetworkWebSocketServerClass, "net.maxon.class.networkwebsocketserver")
 
 MAXON_DECLARATION (Class< NetworkWebSocketClientConnectionRef >, NetworkWebSocketClientConnectionClass, "net.maxon.class.networkwebsocketclientconnection")
 
enum maxon::ZEROCONFACTION MAXON_ENUM_FLAGS (ZEROCONFACTION)
 
enum maxon::ZEROCONFMACHINESTATE MAXON_ENUM_LIST (ZEROCONFMACHINESTATE)
 
enum maxon::ZEROCONFERROR MAXON_ENUM_LIST (ZEROCONFERROR)
 
 MAXON_ATTRIBUTE (void, AssetCategoryNodeContext, "net.maxon.asset.category.nodecontext")
 
enum maxon::NIMBUS_PATH MAXON_ENUM_LIST (NIMBUS_PATH)
 
 MAXON_DATATYPE (WeakNimbusBaseRef, "net.maxon.datatype.weaknimbusref")
 
 MAXON_REGISTRY (NimbusContextGetter, NimbusContextGetters, "net.maxon.registry.nimbuscontextgetters")
 
enum maxon::PyStringEncodings MAXON_ENUM_LIST (PyStringEncodings)
 
enum maxon::OWNERSHIP MAXON_ENUM_LIST (OWNERSHIP)
 
MAXON_ATTRIBUTE_FORCE_INLINE ErrorStorage operator/ (const FunctionRegistration &reg, py::NativePyCFunctionWithKeywords func)
 
 MAXON_REGISTRY (Class< PyModuleRef >, PyModules, "net.maxon.python.registry.pymodules")
 
 MAXON_REGISTRY (Class< LibraryRef >, CPythonLibs, "net.maxon.python.registry.cpythonlibs")
 
py::CPythonLibraryRef PrivateExtractCPythonLibrary3 (py::NativePyObject *self)
 
void _Python3Output (maxon::TARGETAUDIENCE audience, const Char *str, Int line, const Char *file, maxon::WRITEMETA meta=maxon::WRITEMETA::DEFAULT)
 
void _Python3Output (maxon::TARGETAUDIENCE audience, const maxon::String &str, Int line, const Char *file)
 
void _Python3Output (maxon::TARGETAUDIENCE audience, maxon::StringProxy *proxy, Int line, const Char *file)
 
maxon::Error PrivateRegisterCPythonFunc (const Char *name, py::NativePyCFunctionWithKeywords underlyingFunc3, BaseArray< NativePyCFunctionTable > &functions3)
 
void PrivateCPyRefDiagnosticOutput (MAXON_SOURCE_LOCATION_DECLARATION, const Char *refName, const py::CPyRef &ref)
 
template<typename F >
static auto GetSymbol (const DllRef &dll, const CString &symbol)
 
enum maxon::Errno int MAXON_ENUM_LIST (Errno)
 
enum maxon::CONTAINS int MAXON_ENUM_LIST (CONTAINS)
 
enum maxon::VMSETTINGS MAXON_ENUM_FLAGS (VMSETTINGS)
 
enum maxon::VMINITSETTINGS MAXON_ENUM_LIST (VMINITSETTINGS)
 
enum maxon::ERRORHANDLING MAXON_ENUM_LIST (ERRORHANDLING)
 
void DiagnosticOutputFlags (EntityBase::FLAGS flags)
 
void DiagnosticOutputValueKind (const DataType &dt)
 
enum maxon::DEFAULTRUNTIME MAXON_ENUM_LIST (DEFAULTRUNTIME)
 
 MAXON_REGISTRY (Class< VirtualMachineRef >, VirtualMachines, "net.maxon.python.registry.virtualmachines")
 
 MAXON_REGISTRY (VmDebuggerConnectionRef, VmDebuggerConnections, "net.maxon.python.registry.vmdebuggerconnections")
 
 MAXON_DECLARATION (Class< VirtualMachineScopeRef >, CPythonScope, "net.maxon.python.virtualmachine.scope")
 
 MAXON_REGISTRY (VirtualMachineRef, PythonVms, "net.maxon.python.virtualmachines")
 
 MAXON_REGISTRY (Class< FilterRef >, FilterClasses, "net.maxon.renderfilter.registry.filterclasses")
 
 MAXON_REGISTRY (Class< FilterCommandQueueRef >, FilterCommandQueueClasses, "net.maxon.renderfilter.registry.filtercommandqueueclasses")
 
 MAXON_REGISTRY (Class< FilterContextRef >, FilterContextClasses, "net.maxon.renderfilter.registry.filtercontextclasses")
 
 MAXON_REGISTRY (Class< FilterImageRef >, FilterImageClasses, "net.maxon.renderfilter.registry.filterimageclasses")
 
enum maxon::LINEXECUTION MAXON_ENUM_LIST (LINEXECUTION)
 
Block< const ByteToBlock (CFDataRef ref)
 
CFAllocatorRef GetCustomCFAllocator ()
 
CGColorSpaceRef GetSystemColorSpace ()
 
CGColorSpaceRef GetColorSpaceSRGB ()
 
Result< void > CGImageToARGB (CGImageRef image, Int width, Int height, void *buf)
 
CFStrongRef< CFStringRef > ToCFString (const String &in)
 
CFStrongRef< CFStringRef > ToCFString (const CString &in)
 
String CFToString (const CFStringRef in)
 
CFStringRef CreateCFString (const String &in)
 
Result< CFStrongRef< CFURLRef > > ToCFURL (const Url &fn)
 
Result< UrlCFURLToUrl (const CFURLRef fn)
 
Result< UrlGetPreferencesPath (Bool localUser)
 
const CharGetPreferencesPathAsChar (Bool localUser)
 
Result< UrlGetApplicationSupportPath (Bool localUser)
 
Bool GetSysCtlString (const char *what, const Block< Char > &out_str)
 
Bool GetSysCtlString (const char *what, Int32 &out)
 
Bool GetSysCtlString (const char *what, UInt64 &out)
 
 MAXON_PREPROCESSOR_CONDITION (defined(MAXON_TARGET_WINDOWS))
 
enum maxon::GRIDTYPE MAXON_ENUM_LIST (GRIDTYPE)
 
enum maxon::GRIDCLASS MAXON_ENUM_LIST (GRIDCLASS)
 
enum maxon::VECTORGRIDTYPE MAXON_ENUM_LIST (VECTORGRIDTYPE)
 
enum maxon::NANOVDBPRECISION MAXON_ENUM_LIST (NANOVDBPRECISION)
 
 MAXON_DECLARATION (Class< Volume >, VOLUME, "net.maxon.volume.class.volume")
 
enum maxon::VOLUMESAMPLER MAXON_ENUM_LIST (VOLUMESAMPLER, "net.maxon.volume.datatype.enum.volumesampler")
 
 MAXON_DATATYPE (GridAccessorBase, "net.maxon.volume.datatype.gridaccessorbaseref")
 
enum maxon::ITERATORTYPE MAXON_ENUM_LIST (ITERATORTYPE)
 
enum maxon::TREEVOXELLEVEL MAXON_ENUM_LIST (TREEVOXELLEVEL)
 
enum maxon::VOLUME_RAY_TYPE MAXON_ENUM_LIST (VOLUME_RAY_TYPE, "net.maxon.volume.datatype.enum.raytype")
 
 MAXON_DATATYPE (VolumeRayIntersectorBase, "net.maxon.volume.datatype.volumerayintersectorbaseref")
 
enum maxon::POLYGONCONVERSIONFLAGS MAXON_ENUM_FLAGS (POLYGONCONVERSIONFLAGS, "net.maxon.volume.datatype.enum.polygonconversionflags")
 
enum maxon::MIXVECTORTYPE MAXON_ENUM_LIST (MIXVECTORTYPE, "net.maxon.volume.datatype.enum.mixvectortype")
 
enum maxon::SDFFILTERTYPE MAXON_ENUM_LIST (SDFFILTERTYPE, "net.maxon.volume.datatype.enum.sdffiltertype")
 
enum maxon::FILTERTYPE MAXON_ENUM_LIST (FILTERTYPE, "net.maxon.volume.datatype.enum.filtertype")
 
enum maxon::VECTORFILTERTYPE MAXON_ENUM_LIST (VECTORFILTERTYPE, "net.maxon.volume.datatype.enum.vectorfiltertype")
 
enum maxon::FILTERACCURACY MAXON_ENUM_LIST (FILTERACCURACY, "net.maxon.volume.datatype.enum.filteraccuracy")
 
enum maxon::BOOLTYPE MAXON_ENUM_LIST (BOOLTYPE)
 
enum maxon::MIXTYPE MAXON_ENUM_LIST (MIXTYPE)
 
 MAXON_DATATYPE (SDFFilterSettings, "net.maxon.volume.datatype.sdffiltersettings")
 
 MAXON_DATATYPE (FilterSettings, "net.maxon.volume.datatype.filtersettings")
 
enum maxon::RESAMPLEINTERPOLATIONTYPE MAXON_ENUM_LIST (RESAMPLEINTERPOLATIONTYPE, "net.maxon.volume.datatype.enum.resampleinterpolationtype")
 
enum maxon::FIELDLAYER_FLAG MAXON_ENUM_FLAGS (FIELDLAYER_FLAG)
 
 MAXON_DATATYPE (FieldSampleData, "net.maxon.volume.datatype.fieldsampledata")
 
 MAXON_DATATYPE (VolumeConversionPolygon, "net.maxon.volume.datatype.volumeconversionpolygon")
 

Variables

struct maxon::AssetSortData MAXON_ENUM_LIST
 
maxon::CommandAssetInterface MAXON_ENUM_FLAGS
 
constexpr LiteralId URLSCHEME_ASSET
 
constexpr LiteralId URLSCHEME_ASSETDB
 
constexpr LiteralId URLSCHEME_META
 
constexpr LiteralId URLSCHEME_METASQ
 
static constexpr LiteralId ID_MISSINGASSETS
 
static constexpr LiteralId PRESET_DEFAULT_CATEGORY
 
static constexpr LiteralId NODE_PRESET_DEFAULT_CATEGORY
 
static constexpr LiteralId ID_MISSINGNODESPACE
 
static constexpr LiteralId ID_MISSINGPLUGIN
 
template<typename T >
decltype(begin(std::declval< T & >())) TestForBeginFunction (OverloadRank1)
 
template<typename T >
decltype(end(std::declval< T & >())) TestForEndFunction (OverloadRank1)
 
static const NO_MATCH_TYPE NO_MATCH
 
static const UInt32 g_privateDays [2][12]
 
static constexpr Int InvalidArrayIndex
 
static constexpr Int MAXON_FLEXIBLE_ARRAY_LENGTH
 
const void * g_zeroMemory
 
static constexpr Int ZERO_MEMORY_SIZE
 
static constexpr const void *const g_zeroPtr
 
static constexpr ENUM_DONT_INITIALIZE DONT_INITIALIZE
 
static constexpr IN_PLACE_TYPE IN_PLACE
 
Int alignment
 
struct maxon::ValueKindHelper MAXON_ENUM_ORDERED_FLAGS
 
const ARG & src
 
return OK
 
static const Int BASEARRAY_DEFAULT_CHUNK_SIZE
 
static constexpr Int BLOCKARRAY_DEFAULT_SIZE_EXPONENT
 
const BYTEORDER SYSTEM_BYTEORDER
 
constexpr Bool g_hasSSE2
 
constexpr Bool g_hasSSE3
 
constexpr Bool g_hasSSSE3
 
constexpr Bool g_hasSSE4_1
 
constexpr Bool g_hasSSE4_2
 
Bool g_hasAVX
 
Bool g_hasFMA
 
Bool g_hasAES
 
Bool g_hasPCLMULQDQ
 
Bool g_hasAVX2
 
MAXON_ATTRIBUTE_DLL_PUBLIC CpuYieldState::SwitchDelegate g_CpuYieldDelegate
 
Bool g_trackCpuYield
 
Bool g_inCrashhandler
 
static constexpr LiteralId DATADESCRIPTION_CATEGORY_DATA
 
static constexpr LiteralId DATADESCRIPTION_CATEGORY_UI
 
static constexpr LiteralId DATADESCRIPTION_CATEGORY_STRING
 
static constexpr Char EXTENSION_ID_SEPARATOR
 
static const UInt INITIALIZEHASH
 
static const UInt FINALIZEHASH
 
static const UInt VALIDATEHASH
 
template<typename T , GET_DATATYPE_POLICY POLICY, Bool ELEMENTARY>
const DataTypeCache DataTypeCacheInstance< T, POLICY, ELEMENTARY >::_instance & CheckedGetDataType
 
struct maxon::TypeArguments MAXON_ENUM_ORDERED_LIST
 
Char g_writableMemory [1024]
 
template<TranslationUnit & UNIT, UInt64 UNIT_HASH, Bool WEAK, typename NAME >
const maxon::EntityUse g_PrivateDependencyOnModule
 
const UInt32 Mantissa [2048]
 
const UInt16 Offset [64]
 
const UInt32 Exponent [64]
 
const UInt16 Base [512]
 
const UChar Shift [512]
 
static const Int JOBQUEUE_USEMAXIMUMTHREADS
 
static const JobQueueInterface::Current JOBQUEUE_CURRENT
 
static const JobQueueInterface::None JOBQUEUE_NONE
 
static const Int STACKTRACE_SKIP
 
static constexpr Int ADDOBSERVER_DEFAULTPRIORITY
 
static const NO_VALUE_TYPE NO_VALUE
 
constexpr const Int PARALLELFOR_DISABLETHREADING
 
constexpr const Int PARALLELFOR_MAXIMUMDEPTH
 
constexpr const Int PARALLELFOR_DEFAULTGRANULARITY
 
constexpr const Int PARALLELFOR_MINIMUMGRANULARITY
 
constexpr const Int PARALLELFOR_USEMAXIMUMTHREADS
 
static const Float UNKNOWNPROGRESS
 
const Int32 MAXTHREADS
 
const Int32 MaxDataSize
 
const Int32 MaxDataNum
 
const Int32 BYTEMAX
 
static const Int32 RADIXBITS
 
static const Int32 RADIXMASK
 
static const Int32 RADIXBIN
 
Bool g_trackSpinlocks
 
static const Int DEFAULT_APPENDSIZE
 
static const Int STRING_MAXIMUM_PRECISION
 
static const Int STRING_DYNAMIC_DIGITS
 
static constexpr LiteralId LANGUAGE_ENGLISH_ID
 
System::SPECIALBEHAVIOR g_systemBehavior
 
static constexpr Milliseconds MINSLEEPDURATION
 
const Float64 FRAMERATE_DEFAULT
 
const Float64 FRAMERATE_NTSC
 
const Float64 FRAMERATE_PAL
 
const Float64 FRAMERATE_FILM
 
const Float64 FRAMERATE_FILM_NTSC
 
static constexpr Seconds TIMEVALUE_INFINITE
 
static constexpr Seconds TIMEVALUE_INVALID
 
static const IgnoredPlaceholder Ignore
 
static constexpr LiteralId URLSCHEME_HANDLER
 
static constexpr LiteralId URLSCHEME_FILESYSTEM
 
static constexpr LiteralId URLSCHEME_AUTHORITY
 
static constexpr LiteralId URLSCHEME_RELATIVE
 
static constexpr LiteralId URLSCHEME_VOLUME
 
static constexpr LiteralId URLSCHEME_NETWORK
 
static constexpr LiteralId URLSCHEME_STORAGE
 
static constexpr LiteralId URLSCHEME_ZIPFILE
 
static constexpr LiteralId URLSCHEME_GZIPFILE
 
static constexpr LiteralId URLSCHEME_MEMORY
 
static constexpr LiteralId URLSCHEME_TCP
 
static constexpr LiteralId URLSCHEME_WS
 
static constexpr LiteralId URLSCHEME_WSS
 
static constexpr LiteralId URLSCHEME_HTTP
 
static constexpr LiteralId URLSCHEME_HTTPS
 
static constexpr LiteralId URLSCHEME_FTP
 
static constexpr LiteralId URLSCHEME_SFTP
 
static constexpr LiteralId URLSCHEME_PERFORCE
 
static constexpr LiteralId URLSCHEME_CRYPTOFILE
 
static constexpr LiteralId URLSCHEME_CACHE
 
static constexpr LiteralId URLSCHEME_PIPE
 
static constexpr LiteralId URLSCHEME_STDOUT
 
static constexpr LiteralId URLSCHEME_STDERR
 
static constexpr LiteralId URLSCHEME_STDIN
 
static constexpr LiteralId URLSCHEME_APK_ASSET
 
static constexpr LiteralId URLSCHEME_MEMORYFILESTRUCT
 
static constexpr LiteralId URLSCHEME_RAMDISK
 
static constexpr Float32 MINVALUE_FLOAT32
 
static constexpr Float32 MAXVALUE_FLOAT32
 
static constexpr Float64 MINVALUE_FLOAT64
 
static constexpr Float64 MAXVALUE_FLOAT64
 
static constexpr Float32 MINVALUE_INT32_FLOAT32
 
static constexpr Float32 MAXVALUE_INT32_FLOAT32
 
static constexpr Float64 MINVALUE_INT64_FLOAT64
 
static constexpr Float64 MAXVALUE_INT64_FLOAT64
 
static constexpr Float32 MINRANGE_FLOAT32
 
static constexpr Float32 MAXRANGE_FLOAT32
 
static constexpr Float64 MINRANGE_FLOAT64
 
static constexpr Float64 MAXRANGE_FLOAT64
 
static constexpr Float MINVALUE_FLOAT
 
static constexpr Float MAXVALUE_FLOAT
 
static constexpr Float MINRANGE_FLOAT
 
static constexpr Float MAXRANGE_FLOAT
 
static constexpr Int NOTOK
 
static constexpr Float64 PI
 
static constexpr Float64 PI_INV
 
static constexpr Float64 PI2
 
static constexpr Float64 PI2_INV
 
static constexpr Float64 PI05
 
static constexpr Float64 PI05_INV
 
static constexpr Float64 SQRT2
 
static constexpr Float64 SQRT_PI2
 
static constexpr Float64 SQRT2_INV
 
static constexpr Float64 SQRT3
 
static constexpr Float64 LOG2
 
maxon::Bool g_isDebuggerPresent
 
maxon::Bool g_enableDebugBreak
 
JavaHelper g_javaHelper
 
static const ERROR_FAILED FAILED
 
const Error returns_nonnull
 
static HashSet< ThreadedUIUpdateBaseRefg_freeThreadedStuff
 
static Spinlock g_freeThreadedStuffLock
 
static FunctionBaseRef g_exitObservable
 
static Bool g_inShutDown
 
static const Float PERCEIVED_BRIGHTNESS_FACTOR_RED
 
static const Float PERCEIVED_BRIGHTNESS_FACTOR_GREEN
 
static const Float PERCEIVED_BRIGHTNESS_FACTOR_BLUE
 
static const Float PERCEIVED_BRIGHTNESS_CUTOFF
 
static const EffectivePortValue_PrivateHelper & ConstantValue
 
static constexpr Int DYNAMICDEGREE
 
static const Float EPSS
 
static const Int MR
 
static const Int MT
 
static const Int MAXIT
 
static const Float EPS
 
Bool g_enableInCodeProfiler
 
Bool g_enableProfilerDumpRegistry
 
Bool g_enableProfilerDumpRegistryErrors
 
Bool g_enableProfilerGetMethodNameTrace
 
static const Int REGPARSE_CONCAT
 
static const Int REGPARSE_ANYCHAR
 
static const Int REGPARSE_ANYDIGIT
 
static const Int REGPARSE_OPERATOR_OR
 
static const Int REGPARSE_OPERATOR_STAR
 
static const Int REGPARSE_OPERATOR_PARENTHESIS_LEFT
 
static const Int REGPARSE_OPERATOR_PARENTHESIS_RIGHT
 
static const Float POINT_FUSE_EPS
 
static const TimeValue NETWORK_DEFAULT_CONNECT_TIMEOUT
 
static const TimeValue NETWORK_DEFAULT_SESSION_TIMEOUT
 
static const TimeValue SOCKETTIMEOUT_INDEFINITELY
 
static const TimeValue SOCKETTIMEOUT_NEVERBLOCK
 
static const WILDCARD_IPV4_ADDRESS_TYPE WILDCARD_IPV4_ADDRESS
 
static const WILDCARD_IPV6_ADDRESS_TYPE WILDCARD_IPV6_ADDRESS
 
static const Int WILDCARD_IP_PORT
 
const Id ID_LOGGER_PYTHON
 
const Int32 NATIVE_CO_MAXBLOCKS
 

Typedef Documentation

◆ BuildBrowserEntryDelegate

using BuildBrowserEntryDelegate = Delegate<Result<Data>(const AssetBrowserRef& assetBrowser, BUILDBROWSERENTRYCOMMAND cmd, const Data& data, const Data& parent, const BuildBrowserEntryData& add)>

◆ AssetTypeNameMapKey

using AssetTypeNameMapKey = Tuple<AssetRepositoryRef, Id, Id, Id, Bool>

◆ AssetTypeNameMap

◆ InsertPointType

◆ AssetRenaming

using AssetRenaming = Delegate<Result<Id>(const Id& prevId)>

An AssetRenaming represents changes of asset identifiers.

Whenever an asset identifier is changed due to clean-up, refactoring or other reasons, existing assets still reference the asset via its old identifier. You have to register an AssetRenaming to reflect the change.

Parameters
[in]prevIdAn asset identifier.
Returns
The new asset identifier to use instead of prevId, or an empty Id if the AssetRenaming has no replacement for prevId.

◆ AssetUtilities

◆ OutputStreamDecoratorFactory

using OutputStreamDecoratorFactory = Delegate<Result<OutputStreamRef>(const OutputStreamRef& stream)>

A delegate which receives an output stream as parameter and returns either that stream itself or a wrapper stream which decorates the original stream.

Parameters
[in]streamThe stream to decorated.
Returns
The decorated stream, may be stream itself.

◆ AssetRepositoryUpdate

using AssetRepositoryUpdate = Tuple<AssetDescription, BaseArray<AssetBase> >

A tuple where the asset description represents an asset in a repository and the array lists other assets to which the asset's references can be updated. For example if asset A has links to assets B1, C1 but there are newer versions B2, C2, then this is represented by the tuple (A, [B2, C2]).

◆ BuiltinAssetReceiver

using BuiltinAssetReceiver = Delegate<Result<Bool>(const Asset& asset, const DataDictionary& meta, const Url& metaUrl)>

A BuiltinAssetReceiver receives built-in assets from a BuiltinAssetLoaderNew. metaUrl can be left empty, in that case only USER and DERIVED meta data can be written. Non-user, non-derived meta data will be written to metaUrl, but the option g_builtinRepositoryWritable has to be enabled to allow this.

Parameters
[in]assetThe asset to receive.
[in]metaBuilt-in meta data for the asset.
[in]metaUrlAn optional Url where additional meta data can be written to.
Returns
false if the receiver cancelled further evaluation, true otherwise.

◆ BuiltinAssetLoaderNew

using BuiltinAssetLoaderNew = Delegate<Result<Bool>(const Block<const Id>& types, const Id& aid, ASSET_FIND_MODE findMode, const BuiltinAssetReceiver& receiver)>

A BuiltinAssetLoaderNew is used by the built-in asset repository to find built-in assets. You can register such a loader at the BuiltinAssetLoadersNew registry to add new built-in assets.

Parameters
[in]typesThe allowed asset types.
[in]aidThe asset identifier to lookup, use an empty identifier to find all assets.
[in]findModeFlags for the lookup.
[in]receiverAll found assets (plus their meta data and an optional Url to store persistent meta data) are reported to this receiver.
Returns
false if the receiver cancelled further evaluation, true otherwise.

◆ BuiltinAssetLoader

using BuiltinAssetLoader = Delegate<Result<Bool>(const Block<const Id>& types, const Id& aid, ASSET_FIND_MODE findMode, const ValueReceiver<const Asset&, const DataDictionary&>& receiver)>

◆ DndAsset

using DndAsset = Tuple<AssetDescription, Url, String >

Tuple with d&d asset data AssetDescription: asset Url: of the asset String: searchString at the time when the d&d was initiated.

◆ AddAssetMetaData

◆ PresetStorage

using PresetStorage = DataDictionary

◆ DataDescriptionEntry

typedef DataDictionary DataDescriptionEntry

◆ LanguageStringDataDescriptionDefinition

typedef HashMap< Id, DataDescriptionDefinition > LanguageStringDataDescriptionDefinition

◆ LanguageDictionary

using LanguageDictionary = DataDictionary

◆ C4DBaseDocumentType

◆ C4DBaseObjectType

◆ NimbusForwardRef

using NimbusForwardRef = ForwardRefWithExtraBase<NimbusRef, NimbusBaseRef>

◆ CustomLicenseItemDelegate

using CustomLicenseItemDelegate = Delegate<Result<void>(const InternedId& featureId, const String& provider, Bool isValid, const CString& jwtString)>

◆ NodeMaterialLinkResolveFunc

using NodeMaterialLinkResolveFunc = Delegate<Result< ::BaseList2D*>( ::BaseLink* link, ::BaseDocument* baseDocument)>

This delegate allows to custom-define a link resolution to map from Uuid to BaseList2D, for example using another document.

◆ DescCompareEntry

◆ CommandGetStateDelegate

◆ CreateMaterialWithDataDelegate

using CreateMaterialWithDataDelegate = Delegate<::BaseMaterial*(::BaseDocument*, const Data& textureUrlOrColor)>

Allows to register a delegate which will be called when a new material of your type is created from a texture or color (for example when drag&dropping a texture file, a texture asset or a color into the Material Manager) where you must set the data into the material properly. Additionally, your material will appear into the "Cinema 4D Preferences / Material / Material Manager / Default Material" dropdown. Example of use:

// Register Sketch & Toon material
Bool RegisterToonUpMat()
{
return RegisterMaterialPlugin(ID_TOONUP_MAT, GeLoadString(IDS_TOONUPMAT), PLUGINFLAG_MATERIAL_SHOW_IN_DEFAULT_MENU | PLUGINFLAG_HIDEPLUGINMENU | PLUGINFLAG_HIDE, ToonUpMat::Alloc, "Mtoonup"_s, TOONUP_LEVEL_ID);
}
// Register create material delegate
namespace maxon
{
{
CreateMaterialWithDataDelegate delegate = [](::BaseDocument* doc, const Data& textureUrlOrColor) -> ::BaseMaterial*
{
//-----------------------------------------------------------
// Create Skecth&Toon material
//-----------------------------------------------------------
// First try to create a user preset default material
if (!mat)
{
// There is no default preset material: create a new one.
mat = BaseMaterial::Alloc(ID_TOONUP_MAT);
if (!mat)
{
CriticalStop("Hair material creation error: out of memory");
return nullptr;
}
}
//-----------------------------------------------------------
// Set data to material (if any)
//-----------------------------------------------------------
ifnoerr (maxon::Url url = textureUrlOrColor.Get<maxon::Url>())
{
//-----------------------------------------------------------
// Received data is a texture url: set it into the material
//-----------------------------------------------------------
// Activate "Texture" checkbox
// Set texture url
// Delete any unexpected shader (take in mind that if material is a user preset default material, it may contain some unexpected shader)
if (oldShader)
BaseShader::Free(oldShader);
if (newShader != nullptr)
{
// Material takes shader ownership
mat->InsertShader(newShader);
// Set parameter link
}
}
else
{
ifnoerr (maxon::ColorA color = textureUrlOrColor.Get<maxon::ColorA>())
{
//-----------------------------------------------------------
// Received data is a color: set it into the material
//-----------------------------------------------------------
// Set main color
mat->SetParameter(ConstDescID(DescLevel(OUTLINEMAT_COLOR)), color.GetColor3().GetVector(), DESCFLAGS_SET::NONE);
// Set transparency from alpha component
}
}
return mat;
};
return delegate;
}
}
PyObject * value
Definition: abstract.h:715
maxon::Url MaxonConvert(const Filename &fn, MAXONCONVERTMODE convertMode)
Bool RegisterMaterialPlugin(Int32 id, const maxon::String &str, Int32 info, DataAllocator *g, const maxon::String &description, Int32 disklevel)
const String & GeLoadString(Int32 id)
Definition: c4d_basecontainer.h:48
void SetFilename(Int32 id, const Filename &f)
Definition: c4d_basecontainer.h:665
const BaseList2D * GetLink(Int32 id, const BaseDocument *doc, Int32 instanceof=0) const
Definition: c4d_basecontainer.h:488
Definition: c4d_basedocument.h:497
const BaseContainer & GetDataInstanceRef() const
Definition: c4d_baselist.h:2518
void InsertShader(BaseShader *shader, BaseShader *pred=nullptr)
Definition: c4d_baselist.h:2759
const BaseContainer * GetDataInstance() const
Definition: c4d_baselist.h:2530
Definition: c4d_basematerial.h:28
static BaseMaterial * Alloc(Int32 type)
Definition: c4d_basechannel.h:36
static BaseShader * Alloc(Int32 type)
static void Free(BaseShader *&ps)
Bool SetParameter(const DescID &id, const GeData &t_data, DESCFLAGS_SET flags)
static MAXON_METHOD BaseList2D * GetDefaultObject(const Block< const Int32 > &id, BaseDocument *doc)
Definition: url.h:942
Result< typename std::conditional< STD_IS_REPLACEMENT(void, T), typename IsFidClass< KEY >::type, T >::type > Get(KEY &&key) const
Definition: url.h:1002
maxon::Bool Bool
Definition: ge_sys_math.h:51
#define PLUGINFLAG_MATERIAL_SHOW_IN_DEFAULT_MENU
If set, material will appear in Preferences / Material / Material Manager / Default Material dropdown...
Definition: c4d_materialdata.h:38
#define PLUGINFLAG_HIDEPLUGINMENU
Hide the plugin's menu entry.
Definition: c4d_baseplugin.h:31
#define PLUGINFLAG_HIDE
Hide the plugin (for example, in Commander).
Definition: c4d_baseplugin.h:29
Block< T > ToSingletonBlock(T &value)
Definition: block.h:984
#define MAXON_DECLARATION_REGISTER(...)
Definition: module.h:1006
#define ifnoerr(...)
The opposite of iferr.
Definition: errorbase.h:393
#define CriticalStop(...)
Definition: debugdiagnostics.h:231
#define Xbase
Shader base.
Definition: ge_prepass.h:1322
#define Xbitmap
Bitmap.
Definition: ge_prepass.h:1324
#define ConstDescID(...)
Definition: lib_description.h:594
@ OUTLINEMAT_COLOR_TEXTURE
Definition: moutliner.h:615
@ OUTLINEMAT_OPACITY
Definition: moutliner.h:1045
@ OUTLINEMAT_COLOR
Definition: moutliner.h:579
@ OUTLINEMAT_COLOR_TEXTURE_LINK
Definition: moutliner.h:616
The maxon namespace contains all declarations of the MAXON API.
Definition: autoweight.h:14
Delegate<::BaseMaterial *(::BaseDocument *, const Data &textureUrlOrColor)> CreateMaterialWithDataDelegate
Definition: createdefaultmaterialdelegate.h:102
const char * doc
Definition: pyerrors.h:226
Represents a level within a DescID.
Definition: lib_description.h:298
A color consisting of three components R, G, B and an alpha.
Definition: col4.h:16
@ BITMAPSHADER_FILENAME
Definition: xbitmap.h:6

◆ CreateDefaultMaterialDelegate

◆ DescTranslationRef

◆ PyBaseElementFactoryType

using PyBaseElementFactoryType = Factory<PythonElementBaseRef(BaseList2D* bl)>

◆ PyEmbeddedElementFactoryType

using PyEmbeddedElementFactoryType = Factory<PythonElementEmbeddedRef(BaseList2D* bl, const DescID& parameter)>

◆ PyDirectoryElementFactoryType

using PyDirectoryElementFactoryType = Factory<PythonElementBaseRef(Url dir)>

◆ PyScriptElementFactoryType

using PyScriptElementFactoryType = Factory<PythonElementScriptRef(BaseList2D* bl)>

◆ GetExtraDataCallbackType

◆ PatchC4DDescriptionEntryDelegate

◆ CommandCacheMap

using CommandCacheMap = HashMap<Id, CommandCacheRef>

◆ CommandCacheDataRef

◆ ABIReturnType

ABIReturnType<T>::type is an erased type which is compatible with T with respect to the calling convention of the ABI when used for a return value.

See also
ABIParamType
Template Parameters
TType for which the erased, ABI-compatible return type shall be determined.

◆ IndexPair

using IndexPair = Pair<Int, Int>

◆ WritableArrayInterface

WritableArrayInterface is used for function parameters which shall be able to receive any kind of standard array of the MAXON API via the ArrayInterface interface mechanism. You have to use WritableArrayInterface instead of ArrayInterface if you want to modify the array within the function. Example:

void Func(WritableArrayInterface<Char>& array);
BlockArray<Char> myArray;
Func(myArray); // OK
BaseArray<Char> myArray2;
Func(myArray2); // OK
See also
ArrayInterface

◆ BackgroundEntryTuple

using BackgroundEntryTuple = Tuple<WeakRef<BackgroundProgressRef>, Int>

DataType which is added to the url (URLFLAGS::BACKGROUNDJOB) when calling a c4d scene filter/loader maxon::Url url = MaxonConvert(name, MAXONCONVERTMODE::NONE); maxon::BackgroundEntryTuple backgroundJob = url.Get(maxon::URLFLAGS::BACKGROUNDJOB, maxon::BackgroundEntryTuple()); maxon::BackgroundProgressRef job = backgroundJob.first; if (job) { // add the master backgroundJob.second = job.AddProgressJob(1.0, String()) iferr_return; }

◆ BitSet

◆ PersistentIdBuffer

◆ CrashReportPropertyArray

◆ DataDescriptionWithUIAndString

using DataDescriptionWithUIAndString = Tuple<DataDescription , DataDescription , DataDescription >

◆ LanguageStringDataDescription

using LanguageStringDataDescription = HashMap<Id , DataDescription>

◆ DataDescriptionWithUIAndLanguageStrings

using DataDescriptionWithUIAndLanguageStrings = Tuple<DataDescription , DataDescription , LanguageStringDataDescription >

◆ VariadicIdsElement

◆ VariadicIdsType

◆ ContextVarTuple

using ContextVarTuple = Tuple<DataDictionary, GetDataCallbackType>

Tuple which stores the parameters (DataDictionary) of a function call and provides the GetDataCallbackType to evaluate conditions.

◆ ContextVarsMap

Hash map which stores ContextVarTuple for commands.

◆ GetDescEntriesCallbackType

using GetDescEntriesCallbackType = Delegate<Result<Tuple<InternedId, DataDictionary, DataDictionary> >(const InternedId& id, GETDATAFLAGS flags)>

Callback type used for EvaluateCondition which cannot be given a set of descriptions up front. Can also be used to re-path/edit the given #id if needed. For instance, evaluating conditions on a bundle child port needs a relative path that includes the parent ports.

Parameters
[in]idThe id to evaluate, extracted from #condition in EvaluateCondition.
[in]flagsThe evaluation flags, from EvaluateCondition.
Returns
The modified id (later passed to the GetDataCallbackType delegate call), the "data" description entry, the "gui" description entry.

◆ ConditionToken

◆ ProcessEnumListDelegate

using ProcessEnumListDelegate = Delegate<Result<void>(const Id& epId, const DataDictionary& guiEntry, const AssetRepositoryRef& repository, const Data* filterData, const ValueReceiver<Tuple<Id, Data, String>&&>& addValue)>

Callback for registry ProcessEnumListDelegates.

Parameters
[in]epIdThe extension point identifier (for instance "node", "enum", ...).
[in]guiEntryThe description definition DATADESCRIPTION_CATEGORY_GUI entry which defines the enum or preset.
[in]repositoryRepository from where the entries stem.
[in]filterDataSee UseFilterData.
[in]addValueValueReceiver that will be called to process all enum entries generated by the extension point.
Returns
Ok on success.

◆ EnumVariableResolveDelegate

using EnumVariableResolveDelegate = Delegate<Result<CString>(const CString& variable, const CString& fullString, const AssetRepositoryRef& repository, const GetDataCallbackType& getDataCallback, Opt<const DataDictionary&> dataEntry, Opt<const DataDictionary&> guiEntry)>

Callback for registry EnumVariableResolveDelegates.

Parameters
[in]variableThe variable to replace.
[in]fullStringThe full context in which variables are being resolved.
[in]repositoryRepository from where the entries stem.
[in]getDataCallbackCallback used to read read description entry values.
[in]dataEntryOptional. The description definition DATADESCRIPTION_CATEGORY_DATA entry which defines the enum or preset.
[in]guiEntryOptional. The description definition DATADESCRIPTION_CATEGORY_GUI entry which defines the enum or preset.
Returns
A resolved string, should contain no more "{}". Can be turned in an Id or replaced in original string by caller. An error if the variable could not be resolved.

◆ GetDataCallbackType

using GetDataCallbackType = Delegate<Result<Data>(const InternedId& id, const DataDictionary& dataEntry, GETDATAFLAGS flags)>

◆ DataDescriptionDefinitionWithUIAndLanguageStrings

using DataDescriptionDefinitionWithUIAndLanguageStrings = Tuple<DataDescriptionDefinition , DataDescriptionDefinition , LanguageStringDataDescriptionDefinition > MAXON_FORWARD("maxon/datadescriptiondefinition.h")

◆ BuildSubMenuValueReceiver

Value receiver for menu entries. Id - id of the category to add the entry. Empty Id() for no category. SubMenuEntry - entry with the data to present.

◆ DescriptionMessageCheck

Optional delegate to return a pre message check for a description command. DESCRIPTIONMESSAGECHECKFLAGS will be evaluated to disable, hide or check the menu entry.

◆ DescriptionMessageBuildSubMenu

using DescriptionMessageBuildSubMenu = Delegate<Result<void>(const DataDictionary& userData, const BuildSubMenuValueReceiver& menuEntries)>

Optional delegate to return a sub menu structure of a registered description command.

◆ DescriptionMessageCall

using DescriptionMessageCall = Delegate<Result<void>(const DataDictionary& userData, DataDictionary& multiSelectionStorage)>

Delegate which will be called on execution of a registered command.

◆ DescriptionMessageFunction

Combines all delegates for a command registration.

Id: DESCRIPTION::UI::BASE::COMMANDCONTEXT context to which the command belongs to

DescriptionMessageCheck: Callback for the check before presenting the command. This allows to control visibility, enabling, checking,

DescriptionMessageBuildSubMenu: Optional callback to create a submenu structure for this menu entry.

DescriptionMessageCall: Callback for the execution of the command. This must be nullptr if a submenu is provided.

◆ DataFormatReaderFactory

using DataFormatReaderFactory = Factory<DataFormatReaderRef(UrlOrInputStream&&)>

◆ DataFormatWriterFactory

using DataFormatWriterFactory = Factory<DataFormatWriterRef(UrlOrOutputStream&&)>

◆ KeyValueConversionFunc

using KeyValueConversionFunc = void(void*, Char*)

◆ CreateIoHelperFunc

using CreateIoHelperFunc = ResultPtr<void>()

◆ DeleteIoHelperFunc

using DeleteIoHelperFunc = void(void*)

◆ ReadIoHelperFunc

using ReadIoHelperFunc = Result<void>(DataSerializeInterface*, void*, void*, UInt)

◆ WriteIoHelperFunc

using WriteIoHelperFunc = Result<void>(DataSerializeInterface*, void*, void*, UInt)

◆ WidthConversionFunc

using WidthConversionFunc = Bool(void* source, void* dest)

Conversion function for AddWidthConversion from a source to a destination datatype.

Parameters
[in]sourceThe address of the source datatype.
[in]destThe address of the destination datatype.
Returns
True if a conversion was possible, false otherwise.

◆ ReferenceSubstitutionFunction

Substitution function for RegisterObjectSubstitution. The returned ObjectInterface* can be identical to 'input', in that case no substitution takes place. So e.g. only certain types of objects can be translated. Please note that when you create the substitution objects you need to make sure to hold all references yourself (until the complete I/O operation is finished) as the substitution function only returns a pointer and not a reference. Please also note that the input object during reading has the same pointer address it still may be a different object as it is only a temporary object and thus can be at the same address as a previous object.

Parameters
[in]inputThe virtual object created from reading or writing.
Returns
The substituted object.

◆ StreamSubstitutionFunction

using StreamSubstitutionFunction = Delegate<Result<ObjectRef>(ObjectRef input, const Id& compressorId)>

◆ GetChildrenTypesCallback

using GetChildrenTypesCallback = Delegate<Result<Tuple<String, Bool> >(const Member& elementType, const ParametricTypeInterface* parametricType)>

◆ GetDataTypeNameDelegate

using GetDataTypeNameDelegate = Delegate<Result<Tuple<String, String> >(DATATYPEBUILDERNAME category, const DataType& dt, const GetChildrenTypesCallback& getChildrenTypes, const ParametricTypeInterface* parentTypeId, const ParametricTypeInterface** skipParentType)>

◆ GetChildrenCountDelegate

◆ InstantiateDataTypeDelegate

◆ GetParentTypeSupportDelegate

using GetParentTypeSupportDelegate = Delegate<Block<ParametricType>()>

◆ GetFolderDelegate

using GetFolderDelegate = Delegate<Block<const Id>()>

◆ RemoteDateTime

◆ ObjectBaseRef

using ObjectBaseRef = typename maxon::details::ObjectBaseRefImpl<I::REFERENCE_KIND>::type

◆ ValueReceiver

using ValueReceiver = Delegate<Result<Bool>(T...)>

ValueReceiver is a type alias for a Delegate which receives values of the given type(s) T and returns Result<Bool>. ValueReceiver can be used as parameter type of a function which shall generate a number of values of type T in succession. The function will call the receiver once for each such value, and the receiver has the chance to cancel the supply of further values by returning false.

For example a generator function which yields all positive numbers to a ValueReceiver looks like

Result<void> GetPositiveNumbers(const ValueReceiver<Int>& receiver)
{
for (Int i = 1; ; ++i)
{
Bool b = receiver(i) iferr_return;
if (!b)
return OK;
}
}
Py_ssize_t i
Definition: abstract.h:645
maxon::Int Int
Definition: ge_sys_math.h:60
return OK
Definition: apibase.h:2735
#define iferr_scope
Definition: resultbase.h:1389
#define iferr_return
Definition: resultbase.h:1524

All arrays and sets have conversion functions to a ValueReceiver which appends the supplied value to them. So if you want to write a function which shall return a number of values of type T by adding them to a caller-provided array, you can use a ValueReceiver instead of an array for the function parameter. This will not only allow arrays, but arbitrary functions which can even cancel the function if no further values are needed.

Template Parameters
TTypes of values produced by the generator function.

◆ QueryStartupOrder

using QueryStartupOrder = void (*)(BaseArray<Url>& dllsToLoad)

◆ FactoryBase

using FactoryBase = RefBase<FactoryFunctions<FACTORY, FactoryInterface::ReferenceFunctions<RefBaseFn<DirectRef<const FactoryInterface, StrongRefHandler, FACTORY> >> >>
private

◆ Group

using Group = void

special datatype for groups.

◆ GenericData

GenericData wraps an object of arbitary type. It's similar to Data, but with the advantage that you don't need to register the type of the wrapped object as a DataType. This is bought with some restrictions:

  • GenericData can be moved, but it can't be copied.
  • You can obtain the wrapped object with Get, but you have to know it's exact type at compile-time.
  • You can't query the type at runtime. The destructor of the wrapped object will always be called properly.

◆ GenericDataRef

◆ IdAndVersion

using IdAndVersion = Tuple<Id, Id>

IdAndVersion is used for assets to store the asset id (first) and version (second) in a single tuple.

◆ IoProgressDelegate

using IoProgressDelegate = Delegate<Result<void>(Int64 alreadyRead, Int64 totalBytes)>

IoProgressDelegate is used in Url::IoCopyFile to log the progress of the file copy.

Parameters
[in]alreadyReadNumber of bytes already read.
[in]totalBytesNumber of total bytes.
Returns
OK or error. The error could be used to cancel the read operation.

◆ CreateNewMachineCallback

using CreateNewMachineCallback = Delegate<Result<MachineRef>(const String& machineUuid)>

Callback used by FindOrAddRPCMachine. This callback will be called when the machine is not already registered and must be created new.

◆ CheckExistingMachineCallback

using CheckExistingMachineCallback = Delegate<Result<void>(const MachineRef& machineRef)>

Callback used by FindOrAddRPCMachine. This callback will be called when the machine is already registered and will be reused.

◆ CreateObjectRefFunc

using CreateObjectRefFunc = ObjectRef(*)()

Registry to extend MachineInterface::GetInterface(Id)

Returns
ObjectRef to the interface.

◆ WritableMapInterface

using WritableMapInterface = const NonConstMap<K, V>

WritableMapInterface is used for function parameters which shall be able to receive any kind of standard map of the MAXON API via the MapInterface interface mechanism. You have to use WritableMapInterface instead of MapInterface if you want to modify the map within the function. Example:

void Func(WritableMapInterface<Int, String>& map);
HashMap<Int, String> myMap;
Func(myMap); // OK
ArrayMap<Int, String> myMap2;
Func(myMap2); // OK
See also
MapInterface

◆ MultiIndex64

◆ ObservableForwardFunction

using ObservableForwardFunction = Result<Data> (*)(const DelegateBase& observerFunction, const Block<const ConstDataPtr>& data)

◆ FunctionBaseWeakRef

using FunctionBaseWeakRef = WeakRef<FunctionBaseRef>

◆ Optional

using Optional = Opt<T>

◆ MinimalElements

using MinimalElements = MaximalElements<T, ARRAY, COMPARE, KEEP_DUPLICATES, true>

MinimalElements finds the minimal elements of a set of values with a partial order. A minimal element of such a set is an element which is not greater than any other element of the set. A partially ordered set may have more than one minimal element.

To use MinimalElements, add all values via the Append function. Afterwards, you can use MinimalElements like an array, it then will contain the minimal elements of all added values.

For comparison, MinimalElements uses the operator < and <= on the values by default (or just < when KEEP_DUPLICATES is true), but you can override this with the #COMPARE parameter.

Template Parameters
TThe type of values. There has to be a partial order on T defined by COMPARE.
ARRAYAn array selector template to choose the array implementation to use.
COMPAREThe static LessThan and LessThanOrEqual functions of COMPARE are used for value comparisons. When KEEP_DUPLICATES is true, only LessThan needs to be present.
KEEP_DUPLICATESIf true, elements of the set which are equal will be kept each in the array, otherwise only one of them will be in the array.
See also
MaximalElements

◆ JobCancelDelegate

using JobCancelDelegate = Delegate<Result<void>(const ProgressRef& progressRef)>

Delegate used in the ProgressInterface to react on the request to cancel the job.

◆ SecureRandomProvider

using SecureRandomProvider = Pointer<_SecureRandomProvider>

◆ PartialSumSequence

using PartialSumSequence = typename maxon::details::PartialSumSequenceHelper<ZERO_BASED, std::index_sequence<>, 0, VALUES...>::type

◆ WritableSetInterface

WritableSetInterface is used for function parameters which shall be able to receive any kind of standard set of the MAXON API via the SetInterface interface mechanism. You have to use WritableSetInterface instead of SetInterface if you want to modify the set within the function. Example:

void Func(WritableSetInterface<Char>& set);
ArraySet<Char> mySet;
Func(mySet); // OK
HashSet<Char> mySet2;
Func(mySet2); // OK
See also
SetInterface

◆ StreamConversionFactory

using StreamConversionFactory = Factory<StreamConversionRef(const DataDictionary&)>

◆ Synchronized

Synchronized<T> is an alias for SynchronizedValue<T, Spinlock>.

Template Parameters
TType of the contained value.

◆ RWSynchronized

RWSynchronized<T> is an alias for SynchronizedValue<T, ARWLock>.

Template Parameters
TType of the contained value.

◆ ExecuteProgramCallback

using ExecuteProgramCallback = Int32 (*)(SystemProcessObjectRef processRef, EXECUTEPROGRAMCALLBACK cmd, void* userdata, const Url& logfile)

Callback for SystemProcessInterface::StartProcessAndWait return values: return 0 to continue

◆ Pair

using Pair = typename maxon::details::PairSelector<T1, T2>::type

Pair<T1, T2> is an alias for Tuple<T1, T2>.

◆ HomogenousTupleType

Type alias to generate a tuple containing N times type T, i.e. HomogenousTupleType<3, Int> is Tuple<Int, Int, Int>.

◆ UnitsArray

◆ ResultPtr

using ResultPtr = ResultMemT<T*>

ResultPtr<T> wraps a pointer. When the pointer is nullptr, this has to be interpreted as an out-of-memory error condition.

ResultPtr<T> can be used instead of the more general Result<T*> when only out-of-memory conditions can occur in a function. It will lead to more efficient code.

All error handling features of the MAXON API (such as iferr, iferr_return and Result) support ResultPtr.

ResultPtr<T> is just a type alias for ResultMemT<T*>.

◆ ThreadedUIUpdateBaseRef

◆ SingleValueReceiver

using SingleValueReceiver = UniqueValueReceiver<T, ERROR_WHEN_AMBIGUOUS>

SingleValueReceiver will get deprecated.

◆ LIBSSH2_PASSWD_CHANGEREQ_FUNC

using LIBSSH2_PASSWD_CHANGEREQ_FUNC = void(*)(LIBSSH2_SESSION *session, char **newpw, int *newpw_len, void **abstract)

◆ sslctxsetverifycallback

typedef int(* sslctxsetverifycallback) (int, X509_STORE_CTX *)

◆ TimeStamp

using TimeStamp = UInt64

◆ GraphConnection

GraphConnection represents a connection between two ports of a graph. For a pair of connected ports, one GraphConnection is stored at the source port and another one at the target port. The first tuple value represents the other end of the connection, the second tuple value the wires modes of the connection.

◆ NodeConnection

using NodeConnection = Tuple<NodePath, NodePath>

IoNodeConnection represents the start and end points of a connection. Tuple<source node and port path, node and port path>.

◆ IoNodePath

using IoNodePath = Tuple<NodePath, InternedId>

Deprecated. Not used anymore. Use NodePath instead.

◆ IoNodeConnection

Deprecated. Not used anymore. Use NodeConnection instead.

◆ IoGraphNode

Deprecated. Not used anymore. Use GraphNode instead.

◆ GraphAttributeMap

A GraphAttributeMap collects the current values of attributes of a node or port, see GraphModelInterface::GetValues.

◆ PathBlock

using PathBlock = Block<const InternedId>

A PathBlock is a Block of identifiers to be used as path into a graph, see NodePath.

◆ DrawDimensionInt

◆ DrawDimensionFloat

◆ DrawRectInt

DrawRect for Int types.

◆ DrawRectFloat

DrawRect for Float types.

◆ DrawPoint3dInt

DrawPoint3d for Int types.

◆ DrawPoint3dFloat

DrawPoint3d for Float types.

◆ DrawDimension3dInt

◆ DrawDimension3dFloat

◆ DrawVolumeInt

DrawVolume for Int types.

◆ DrawVolumeFloat

DrawVolume for Float types.

◆ UpdateRegion

Typedef for a Update Region which contains the boundary of a modified range of pixels.

◆ BitDepthConfig

using BitDepthConfig = const DataType

◆ MediaOutputSelectionHandler

using MediaOutputSelectionHandler = Delegate<Result<SELECTIONHANDLERRESULT>(const MediaStreamRef& stream, const MediaStreamFormat& props)>

The selection handler will be called for every stream which is detected in output texture.

◆ MediaSessionProgressCallback

using MediaSessionProgressCallback = Delegate<void(const ProgressRef& progress, Float percent, const TimeValue& duration, const TimeValue& expectedTotalTime)>

Delegate which is triggered if MediaSession loaders notify about some progress when loading files.

Parameters
[in]progressProgressRef which notifies.
[in]percentoverall percent of the progress
[in]durationtime since the operation started.
[in]expectedTotalTimerough guess how load the operatin will take in total.

◆ AnimBlendTweenCallback

using AnimBlendTweenCallback = Delegate<void(const BlendAnimationRef& self, const BlendTweenRef& tween, ANIMBLENDSTATE state, const Data& animValue)>

◆ Complex32

Single-precision complex number.

◆ Complex64

Double-precision complex number.

◆ MatrixNxM32

Single-precision n x m matrix.

◆ MatrixNxM64

Double-precision n x m matrix.

◆ MatrixNxMComplex32

single-precision complex n x m matrix.

◆ MatrixNxMComplex64

Double-precision complex n x m matrix.

◆ PRSMatrix64

◆ PRSMatrix32

◆ PRSMatrix

◆ Quaternion32

Single-precision quaternion.

◆ Quaternion64

Double-precision quaternion.

◆ enable_if_scalar

using enable_if_scalar = typename std::enable_if<STD_IS_REPLACEMENT(scalar, T), T>::type

Helpers for shorter function names.

◆ enable_if_not_scalar

using enable_if_not_scalar = typename std::enable_if<!STD_IS_REPLACEMENT(scalar, T), T>::type

◆ enable_if_float

using enable_if_float = typename std::enable_if<STD_IS_REPLACEMENT(floating_point, T), T>::type

◆ enable_if_not_float

using enable_if_not_float = typename std::enable_if<!STD_IS_REPLACEMENT(floating_point, T), T>::type

◆ enable_if_integral

using enable_if_integral = typename std::enable_if<STD_IS_REPLACEMENT(integral, T), T>::type

◆ enable_if_not_integral

using enable_if_not_integral = typename std::enable_if<!STD_IS_REPLACEMENT(integral, T), T>::type

◆ VariadicInstance

using VariadicInstance = Tuple<Id, DataDictionary>

This tuple holds the information for an instance of a variadic port: The Id is the port identifier, and the DataDictionary contains additional parameters for the instance.

◆ IconProvider

using IconProvider = Delegate<Result<Url>(const CString&)>

An icon provider is queried to return a Url of an icon file (png or svg) for a given CString identifier. The identifier can stem e.g. from the NODE::BASE::ICON attribute of a node resource. To resolve such an identifier to a Url, all icon providers registered at the IconProviders registry are queried by GetUrlFromIconProviders(), and the first one which returns a non-null Url will be used.

◆ SubDataPath

◆ SubDataPathBlock

using SubDataPathBlock = Block<const Data>

◆ EdgePair

◆ IndexType

using IndexType = Int32

◆ EdgeNeigborPolygons

◆ SimplePolygon

Polygon class for simple triangles/quadrangles that is compatible with Melange. It uses Int32 as data type while the new MeshPolygon uses MeshValue/UInt32.

◆ UVWPolygon

◆ TangentPair

◆ TangentPair2d

< 3d Tangent basic data type

◆ AioBuffer

◆ SOCKET

typedef int SOCKET

◆ ReturnResolveError

using ReturnResolveError = Result<void>

◆ SSH_CHANGE_PASSWORD_CALLBACK

using SSH_CHANGE_PASSWORD_CALLBACK = void(*)(String& newPassword)

◆ NETWORKCHAR

typedef Char NETWORKCHAR

◆ SocketT

typedef int SocketT

◆ HandleRequestDelegate

using HandleRequestDelegate = Delegate<Result<void>(const NetworkWebServerRef& server, const NetworkHttpHandlerRef& remoteConnection, const String& file, const DataDictionary& request)>

◆ IndexSelectionType

◆ IndexSelection

◆ WeakNimbusBaseRef

using WeakNimbusBaseRef = WeakRef<NimbusBaseRef>

◆ NimbusContextGetter

using NimbusContextGetter = Delegate<Result<Data>(const NimbusBaseRef& nimbus)>

Delegate type for NimbusContextGetters.

Parameters
[in]nimbusThe nimbus object which defines the context.
Returns
The context value derived from the nimbus object.

◆ FunctionRegistration

◆ NativePyCFunctionTable

◆ PyChar

using PyChar = Char

◆ FilterProgressMonitorFunction

using FilterProgressMonitorFunction = Bool (*)(void* userPtr, Float progress)

◆ TestsFinishedDelegate

◆ TestsErrorDelegate

using TestsErrorDelegate = Delegate<void(Result<void>, const maxon::String& line)>

◆ LineDelegate

using LineDelegate = Delegate<LINEXECUTION(const maxon::String& line, const maxon::Url& location)>

◆ AutoExeArgs

◆ CFAutoReference

compatibility: Use CFStrongRef

◆ NSAutoReference

compatibility: Use NSStrongRef

◆ GridAccessorBase

◆ VolumeRayIntersectorBase

◆ DelegatePointObjectsPair

using DelegatePointObjectsPair = Pair<Delegate<Result<void>(void*, PointsToVolumeListRef&)>, BaseArray<void*> >

◆ DelegatePointObjectsPairList

Enumeration Type Documentation

◆ ASSETBROWSERMODE

enum ASSETBROWSERMODE
strong
Enumerator
UNDEFINED 
CATEGORIES 
ASSETS 
KEYWORDSAVAILABLE 
KEYWORDSASSIGNED 
VERSIONS 
DEPENDENCIES 
DEPENDANTS 
DATABASES 

◆ ASSETGROUPBY

enum ASSETGROUPBY
strong
Enumerator
UNDEFINED 
CATEGORY 
CREATIONDATE 
USEDATE 
USECOUNT 
TYPE 
DATABASE 
NOTHING 
_MAX 

◆ ASSETSORTBY

enum ASSETSORTBY
strong
Enumerator
UNDEFINED 
NAME 
MODIFICATION_DATE 
CREATION_DATE 
USEDATE 
USE_COUNT 
SIZE 
RELEVANCE 

◆ ASSETSORTFIRST

enum ASSETSORTFIRST
strong
Enumerator
UNDEFINED 
NONE 
FAVORITES 
RELEVANT 

◆ ASSETSORTORDER

enum ASSETSORTORDER
strong
Enumerator
NONE 
ASCENDING 
DESCENDING 

◆ ASSETRELEVANCECONTEXT

enum ASSETRELEVANCECONTEXT
strong
Enumerator
UNDEFINED 
OBJECT_OM 
OBJECT_VP 
MESH 
SPLINE 
MATERIAL 
UV_EDITOR 
UV_VP 
NODE 
OTHER 

◆ REPOSITORYSTATE

enum REPOSITORYSTATE
strong
Enumerator
NONE 
INTERNAL 
MOUNTED 
READONLY 
DATABASE 
WATCHFOLDER 
ONLINE 
COMPACTABLE 
ACTIVE 
ERROR 

◆ FILTERASSETRESULT

enum FILTERASSETRESULT
strong
Enumerator
SKIP 
ADD 
ADDCATEGORYONLY 

◆ MASTERFILTER

enum MASTERFILTER
strong
Enumerator
ALL 

Filter for all types.

OBJECTS 

Filter for object assets only.

MATERIALS 

Filter for material assets only.

MEDIA 

Filter for media assets only.

NODES 

Filter for node assets only.

SCENE_NODES 

Filter for scene nodes only.

SCENES 

Filter for scene files only.

PRESETS 

Filter for presets only.

TOOLCOMMANDS 

Filter for tool commands only.

OBJECTCOMMANDS 

Filter for object commands only.

OTHERCOMMANDS 

FIlter for other commands only.

SPECIAL 

Filter for special mode.

◆ LENGTHUNITSYSTEM

enum LENGTHUNITSYSTEM
strong
Enumerator
METRIC 
IMPERIAL 

◆ BUILDBROWSERENTRYCOMMAND

Enumerator
START 

returned value is passed as data into all callbacks

END 

'data' contains the data returned in START, 'parent' data contains a boolean if the job was canceled

RESET 

'data' contains the data returned in START, called before the first element is added

ADD 

'data' contains the data returned in START, 'parent' contains the parent returned in the parent ADD operation

SELECT 

'data' contains the data returned in START, 'parent' contains the Id of the element that should be selected

◆ DOWNLOADSTATE

enum DOWNLOADSTATE
strong
Enumerator
NO 
YES 
INPROGRESS 
ERROR 
UNAVAILABLE 

◆ ASSETLICENSETYPE

enum ASSETLICENSETYPE : UInt64
strong
Enumerator
NONE 
ENABLE_IN_SUBSCRIPTION 
SHOW_IN_SUBSCRIPTION 
ENABLE_IN_PERPETUAL 
SHOW_IN_PERPETUAL 
ENABLE_IN_TRIAL 
SHOW_IN_TRIAL 
ENABLE_IN_LITE 
SHOW_IN_LITE 
ENABLE_IN_STUDENT 
SHOW_IN_STUDENT 
ENABLE_IN_EDUCATION 
SHOW_IN_EDUCATION 
ENABLE_IN_CINEWARE 
SHOW_IN_CINEWARE 
ONLY_IN_MAXONONE 
ENABLE_IN_ALL 
SHOW_IN_ALL 
ALLBITS 

◆ ASSET_FIND_MODE

enum ASSET_FIND_MODE
strong

The flags of ASSET_FIND_MODE control the behavior of AssetRepositoryInterface::FindAssets.

Enumerator
NONE 

No flag set.

LATEST 

Set this flag to obtain only the latest version of the asset.

ALL 

Set this flag to obtain all versions of the asset.

WITHOUT_BASES 

Set this flag if the asset shouldn't be looked up in base repositories.

WITH_DELETED 

Set this flag to also find deleted assets.

PREFIX 

Set this flag to include assets for which the given identifier is a prefix of their identifier.

RANDOMIZED_ORDER 

Set this flag when you want to get assets in randomized order, this is useful for parallelized code.

CHECK_CANCELLATION 

Set this flag when you want to check if the job is cancelled. if cancelled a OperationCancelledError is returned.

PRIVATE_QUERY_REPOSITORY_VISIBILITY 

Private: if this flag is given then the delegate is called at the beginning of each findasset if the repository, the const AssetDescription& points to a const AssetRespsitoryRef&.

◆ REPOSITORYINDEXSTATE

enum REPOSITORYINDEXSTATE
strong
Enumerator
NONE 
PENDING 
RUNNING 
EXISTS 

◆ OUTPUTLOCATION

enum OUTPUTLOCATION
strong
Enumerator
BETA 
C4D 
NET 
ALL 

◆ ASSETINSERTOBJECTMODE

enum ASSETINSERTOBJECTMODE
strong

used as parameter in AssetCreationInterface::CreateObjectsOnDrag()

Enumerator
ASOBJECT 

create new assets as an individual object

ASINSTANCE 

if one object of the same object was already dragged into the scene create a instance

ASRENDERINSTANCE 

if one object of the same object was already dragged into the scene create a render instance

ASXREF 

if one object of the same object was already dragged into the scene create a legacy xref

◆ GENERATESCENEPREVIEWIMAGEFLAGS

Enumerator
NONE 
ISORIGINALDOCUMENT 

if set the document will be cloned for rendering, otherwise the document will be used and modified directly.

FRAMESCENE 

frames the scene before rendering

PREVIEWRENDER 

use the preview renderer instead of the selected render engine

GEOMETRYONLY 

apply geometry only rendering to the scene (in case of PREVIEWRENDER)

AUTODETECT_RENDERENGINE 

detect render engine from document

◆ OPENSAVEASSETDIALOGFLAGS

Enumerator
NONE 
ALLOW_EDIT_ID 

enabled the editfield of the assset id to allow the user editing of the id.

ALLOW_EDIT_NAME 

allows to edit the name of the asset

SHOW_VERSION 

shows the version edit field to let the user enter a version name

ALLOW_EMPTY_CATEGORY 

set to allow to clear the category (make it blank). otherwise the user needs to choose a category.

SHOW_MAKE_DEFAULT 

enabled the "make as default" checkbox for presets.

◆ ASSETPOPUPOPTIONS

enum ASSETPOPUPOPTIONS
strong
Enumerator
NONE 
POPUPMODE 

opens the manager in popup mode

MODAL 

opens a modal dialog

EXECUTELOAD 

in POPUPMODE mode do not call the resultCallback, but execute the load on doubleclick directly

ALLOWDRAGANDDROP 

enables d&d out of the manager

ALLOWPINPOPUP 

show pin button to make dialog sticky

SUBDIALOG 
SHOWCATEGORIESONLY 

special mode to select only categories

SHOWKEYWORDSONLY 

special mode to select only keywords

SHOWCATEGORYLIST 

enables the category list for selections

SHOWQUICKTABS 

enables the visibility of the quicktabs

DISPLAYASLIST 

displays the popup as list instead of gridview

HIDEWATCHFOLDERS 

Hides Watchfolder categories.

COMMANDER 

@markprivate

◆ VIEW_MODE

enum VIEW_MODE
strong
Enumerator
LIST 
GRID 

◆ COMMANDSTATE

enum COMMANDSTATE
strong

Defines if a command can be executed or not.

Enumerator
DISABLED 

The command can't be executed.

ENABLED 

The command can be executed.

◆ COMMANDRESULT

enum COMMANDRESULT
strong

Defines the result of the command after execution.

Enumerator
OK 

The command was executed properly.

SKIP 

The command did not execute because no action was necessary (e.g. no selection).

BREAK 

The command execution was interrupted.

◆ INTERACTIONTYPE

enum INTERACTIONTYPE
strong

Defines the interactivity mode.

Enumerator
NONE 

No interaction.

START 

Interaction start (e.g. first mouse click).

ITERATE 

Interaction iteration, performed several times after START (e.g. mouse drag).

END 

Interaction end (e.g. mouse released).

REALTIME 

Real-time iterative interaction (e.g. cursor over viewport).

◆ MOVE_MODE

enum MOVE_MODE
strong
Enumerator
KEEP_SOURCE 
DESTRUCT_SOURCE 

◆ NO_MATCH_TYPE

enum NO_MATCH_TYPE
strong
Enumerator
VALUE 

◆ VALUEKIND

enum VALUEKIND : UInt64
strong

This enum is used for DataType as a classification of the kind of values which the DataType represents. Actual values are composed of several flags.

Enumerator
NONE 
VOID_TYPE 

The data type represents the void type.

GENERIC 

The data type represents the Generic type.

GENERIC_ARITHMETIC 

The data type is the abstract base type of all arithmetic types.

SCALAR 

The type is a scalar type.

INTEGRAL 

The type is an integral type (that doesn't include enumeration types).

FLOATING_POINT 

The type is a floating point type.

ENUM 

The data type is an unnamed enum type created by DataTypeLib::GetEnumType().

DATA 

The data type is Data.

DATAPTR 

The data type is one of ConstDataPtr, DataPtr, MoveDataPtr or ForwardingDataPtr.

NONVIRTUAL_INTERFACE 

The data type is a non-virtual interface.

VIRTUAL_INTERFACE 

The data type consists of a set of virtual interfaces.

REF_OR_POINTER 

This flag is set for a BaseRef-like reference or a pointer.

POINTER 

The data type is an ordinary C++ pointer, or a BaseRef with raw pointer semantics, or a C++ reference (then one of LV_REFERENCE or RV_REFERENCE is also set).

STRONG_REFERENCE 

The data type is a BaseRef with non-copy-on-write reference-counting semantics.

COW_REFERENCE 

The data type is a BaseRef with copy-on-write semantics.

UNIQUE_REFERENCE 

The data type is a BaseRef with unique ownership, i.e., the referenced object will be freed on destruction of the BaseRef.

ACOW_REFERENCE 

The data type is a BaseRef with always-copy-on-write semantics.

LV_REFERENCE 

The type is an l-value reference type. This flag can only be set in conjunction with POINTER, i.e., C++ references are treated as special pointers.

RV_REFERENCE 

The type is an r-value reference type. This flag can only be set in conjunction with POINTER, i.e., C++ references are treated as special pointers.

TUPLE 

The data type is a TupleDataType with anonymous members created by ParametricTypes::Tuple.

STRUCT 

The data type has an underlying TupleDataType with named members.

SIMD 

The data type is a SimdElementType. Such a type has a special memory layout where consecutive elements overlap in memory.

BLOCK 

The data type is a Block.

STRIDED_BLOCK 

The data type is a strided Block.

BASEARRAY 

The data type is a BaseArray type.

BLOCKARRAY 

The data type is a BlockArray type.

RESULT 

The data type is a Result.

DELEGATE 

The type is a DelegateDataType.

FUNCTION 

The type is a FunctionDataType (i.e., a Function<> bound to input and output types).

CONST_QUALIFIED 

The type is const-qualified.

SOURCE_LEVEL 

The data type is a type at sourcecode level which is represented by a different architecture- and version-dependent type at runtime.

DEEP_CONSTNESS 

The data type obeys deep constness.

INT_SIZE_OR_LESS 

Values of the data type fit into an Int.

ZERO_INITIALIZED 

Values of the data type are initialized with zeroes by their default constructor, also set for scalar types.

ORDERED 

Values of the data type are ordered (DataType::Compare can be used and implements a total order).

TRIVIALLY_CONSTRUCTIBLE 

Values of the data type are trivially constructible.

TRIVIALLY_DESTRUCTIBLE 

Values of the data type are trivially destructible.

TRIVIALLY_COPYABLE 

Values of the data type are trivially copyable.

TRIVIALLY_EQUATABLE 

Values of the data type are trivially equatable (see IsTriviallyEquatable).

TRIVIALLY_HASHABLE 

Values of the data type are trivially hashable (see IsTriviallyHashable).

OBJECT_REF 

This flag is set for a reference or pointer to a virtual object.

VALUE 

This flag is set if the type is a value type (such as a scalar, a COW reference or a tuple or array of value types).

ELEMENT_TYPE_AS_ARG 

This flag is set for a parametric type which uses the element type to store the type arguments of the instantiation.

NEVER_NULLPTR 

This flag is set for pointer or reference types which never hold a nullptr value.

SIGNED 

This flag is set for floating point and signed integer types.

GENERIC_INSTANTIATION 

The data type is an instantiation of a generic base type for given arguments.

ABSTRACT 

The data type is an abstract type (for example Generic or an interface type).

NAMED 

This flag is set for tuple or container types with named members.

CONTAINER_REF 

The data type is a reference type of a container type.

GENERIC_CONTAINER 

This flag may be set for container types to indicate generic members.

RECURSIVE_CONTAINER 

The data type represents a recursive container type.

RESOLVED_RECURSIVE_CONTAINER 

The data type represents a resolved recursive container type (i.e. the underlying type points to the enclosing container type).

CONTAINER 

The data type is a ContainerDataType.

EMPTY_CONTAINER 

The data type is a ContainerDataType.

VIRTUAL_TUPLE_CONTAINER 

The data type is a ContainerDataType.

STATIC_ARRAY_CONTAINER 

The data type is a ContainerDataType.

ARRAY_CONTAINER 

The data type is a ContainerDataType.

ARRAY 

The data type is an ArrayInterface type obtained by DataType::GetArrayType().

CONTAINER_MASK 

The data type is a ContainerDataType.

NAMED_TUPLE 

The data type is a TupleDataType with named members created by ParametricTypes::Tuple.

CONTAINS_RECURSIVE_CONTAINER 

The data type directly or indirectly contains a recursive container type.

CONTAINS_INVALID_TYPE 

The data type directly or indirectly contains the InvalidType.

BUNDLE 

The data type is a bundle type.

MIN_DERIVED_CONTAINER 
MIN_ARRAY_CONTAINER 
MAX_ARRAY_CONTAINER 
COW_MASK 

Test mask to check for copy-on-write reference semantics.

STRONG_MASK 

Test mask to check for reference counting semantics.

PTR_MASK 

Test mask any kind of pointer/reference.

CONTAINER_OR_REF 
REFERENCE_MASK 
ARITHMETIC_MASK 

Test mask for concrete arithmetic types.

TUPLE_MASK 
TUPLE_INHERIT_MASK 
POINTER_FLAGS 

The VALUEKIND of a pointer.

QUALIFIER_MASK 
CONTAINS_MASK 

◆ COLLECTION_KIND

enum COLLECTION_KIND
strong

Possible kinds of a collection.

See also
GetCollectionKind
Enumerator
NONE 

Not a collection.

ARRAY 

The collection is an array.

SET 

The collection is a set.

MAP 

The collection is a map.

◆ BYTEORDER

enum BYTEORDER
strong

The byte order of data type which is longer than one byte. You can use SYSTEM_BYTEORDER to determine the current system byte order.

Enumerator
BIG 

Big Endian Format, used on Motorola and IBM Processors (e.g. PowerPC)

LITTLE 

Little Endian Format, used on Intel and ARM Processors.

◆ CONFIGURATION_CATEGORY

Help Category for configuration values.

Enumerator
REGULAR 

Help will be shown when application is started with command line parameter help. Use this value for configuration variables that are relevant to an end-user.

DEVELOPMENT 

Help will be shown when application is started with command line parameter help=dev. Use this value for configuration variables that are relevant to a developer.

MODULE 

Help will be shown when application is started with command line parameter help=module. Don't use this for your own variables.

EXTENSION 

Help will be shown when application is started with command line parameter help=extension. Don't use this for your own variables.

IMPLEMENTATION 

Help will be shown when application is started with command line parameter help=impl. Don't use this for your own variables.

NONE 

No help will be shown.

SUBSCRIBER 

This entry jjust copies whatever setting has been assigned to the owner.

◆ CONFIGURATIONENTRY_ORIGIN

Source where a configuration value was defined.

Enumerator
APPLICATION 

Configuration value was defined by the application itself.

CONFIGURATION 

Configuration value originated from a configuration file.

ENVIRONMENT 

Configuration value originated from an environment variable.

COMMANDLINE 

Configuration value originated from a command line parameter.

◆ CONFIGURATIONENTRY_STATE

State of a configuration value.

Enumerator
UNUSED 

Configuration value was not used by or known to the application. This is e.g. true for environment variables that the application cannot process.

INVALIDARGUMENT 

Configuration value was recognized by the application, but argument was invalid.

USED 

Configuration value was recognized and successfully used by the application.

OUTOFRANGE 

Configuration value was recognized by the application, but argument was out of range. The value has been clamped and is now valid.

◆ CONDITIONTOKENTYPE

enum CONDITIONTOKENTYPE
strong

Condition token types extracted by DataDescriptionUIInterface::TokenizeCondition.

Enumerator
NONE 
ATTRIBUTEID 
DYN_ATTRIBUTEID 

Identifier for which DataDescriptionDefinitionInterface::GetDataValueOrDefaults will be called.

VARIABLE 

Same as ATTRIBUTEID but the attribute is animated, this makes the whole condition bypassed as true.

CONSTANT 

External variable, see DataDescriptionDefinitionInterface::EvaluateCondition.

FUNCTION 

Constant value for comparison.

OPERATOR 

A function call.

PARENTHESIS 

Comparison operator, logic operator, this token often contains constants and parenthesis.

◆ GETDATAFLAGS

enum GETDATAFLAGS
strong

Flags used in combination with GetDataCallbackType.

Enumerator
NONE 

no flags

INTENT_ENABLING 

Set this flag to get the effective value for the enabling with out port links (but the effective coming from the linked port)

INTENT_ENABLING_ISCONNECTED 

Check only if the property is connected.

INTENT_ENABLING_GRAPHNODE 

Return the GraphNode of the property.

INTENT_ENABLING_HASVALUE 

Same as INTENT_ENABLING, but limited to value, will not return a type when no value is present.

INTENT_GET_TRANSLATEDCHILDREN 

Fetch TRANSLATEDCHILDREN attribute from a port's EffectivePortDescription.

◆ DBVERSION

enum DBVERSION
strong

used in FixDatabaseProps.

Enumerator
S22 
R23_CONVERTLIMIT 

convert limit Bool to enum

R23_CONVERTENUM 

convert .enum and .command. to #enum and #command#

R23_CONVERTENUM2 

convert .enum and .command. fixes ITEM#328085 [RE] Strings Translation tool deletes already translated strings

R23_DBVERSIONIDTYPE 

removes the old dbversion type

CURRENT 

◆ DESCRIPTIONMESSAGECHECKFLAGS

used in DescriptionMessageCheck.

Enumerator
NONE 

no flags

ENABLED 

menu entry should be enable.

VISIBLE 

visible menu entry is visible

CHECKED 

menu entry is checked with a check mark symbol.

SORTSUBMENU 

true to sort sub menu entries

◆ LOADDESCRIPTIONMODE

enum LOADDESCRIPTIONMODE
strong
Enumerator
COMPLETE 

returns the complete description

OVERWRITTEN 

returns the data description editor description with overwritten parameters.

◆ PREPAREHELPERFLAGS

enum PREPAREHELPERFLAGS
strong

Flags to describe the properties of I/O helper classes.

Enumerator
NONE 
INITIALIZE_READ 

The helper's ReadAction will get a call with INITIALIZEHASH before the class has been read.

INITIALIZE_WRITE 

The helper's WriteAction will get a call with INITIALIZEHASH before the class has been written.

FINALIZE_READ 

The helper's ReadAction will get a call with FINALIZEHASH after the class has been read.

FINALIZE_WRITE 

The helper's WriteAction will get a call with FINALIZEHASH after the class has been written.

VALIDATE_STATE 

The helper's ReadAction will get a call after all input operations are finished. Objects that interact with others can then update necessary information.

◆ DATATYPEBUILDERNAME

enum DATATYPEBUILDERNAME
strong
Enumerator
HUMAN_READABLE 
CODE_CPP 

◆ DAYOFWEEK

enum DAYOFWEEK
strong

Day of Week.

Enumerator
MONDAY 

Monday.

TUESDAY 

Tuesday.

WEDNESDAY 

Wednesday.

THURSDAY 

Thursday.

FRIDAY 

Friday.

SATURDAY 

Saturday.

SUNDAY 

Sunday.

◆ DST

enum DST : Int16
strong

Daylight Saving Time information.

Enumerator
AUTOMATIC 

When a date-time object gets converted the Daylight Saving Time is automatically detected and added.

NOTSET 

When a date-time object gets converted the Daylight Saving Time is not added to the target time.

SET 

When a date-time object gets converted the Daylight Saving Time is added to the target time.

◆ JULIANDATE

enum JULIANDATE
strong

Variants of Julian Day.

Enumerator
STANDARD 

Standard variant with epoch of 12h Jan 1, 4713 BC.

REDUCED 

Reduced JD with epoch of 12h Nov 16, 1858.

MODIFIED 

Modified variant with epoch of 0h Nov 17, 1858.

LEGACY 

Legacy mode with Julian Day + 0.5.

TRUNCATED 

Truncated variant with epoch of 0h May 24, 1968.

DUBLIN 

Dublin variant with epoch of 12h Dec 31, 1899.

LILIAN 

Lilian variant with epoch of Oct 15, 1582[9].

RATEDIE 

Rate Die variant with epoch of Jan 1, 1, proleptic Gregorian calendar.

UNIXTIME 

Unix Time variant with epoch of 0h Jan 1, 1970.

MARSSOL 

Mars Sol Date variant with epoch of 12h Dec 29, 1873.

◆ HARDWAREBREAKPOINTTYPE

Hardware breakpoint type.

Enumerator
CODE 

Throws an exception when the program counter touches the code at the watch address.

READWRITE 

Throws an exception when the watched memory will be read or written.

WRITE 

Throws an exception when the watched memory will be written.

◆ HARDWAREBREAKPOINTSIZE

Hardware breakpoint size.

Enumerator
SIZE1 

1 byte.

SIZE2 

2 bytes.

SIZE4 

4 bytes.

SIZE8 

8 bytes.

◆ NULL_RETURN_REASON

enum NULL_RETURN_REASON
strong
Enumerator
NULLPTR 
MAKE_WRITABLE_FAILED 
UNRESOLVED 
NULLIMPL 

◆ FILEFORMATDETECTIONFLAGS

Enumerator
NONE 
FASTDETECTION 

perform a faster detection when scanning many files (e.g. check suffixes before running real identification code for windows media foundation movies files because windows needs 500 ms for each)

◆ FILEFORMAT_PRIORITY

enum FILEFORMAT_PRIORITY
strong

FILEFORMAT_PRIORITY defines the priority order of file formats. The lower the value the later it will be called.

Enumerator
SHIFT_ONE 

Add/Sub this value to in/decrease the priority by 1.

SHIFT_TEN 

Add/sub this value to in/decrease the priority by 10.

FALLBACKFORMAT 

Specifies the lowest priority of a file format.

GENERALFORMAT 

Specifies the medium priority of a file format. This should be used for general loaders which handle many formats through other APIS (e.g. ffmpeg)

NATIVEFORMAT 

Specifies the highest priority of a file format. This should be used for native implementations (e.g. image formats like jpg, tif done by us).

◆ ASSET_UPDATE_POLICY

enum ASSET_UPDATE_POLICY
strong

ASSET_UPDATE_POLICY controls how the referenced asset of an AssetLink is updated when a newer version of the asset exists.

Enumerator
NEVER 

The asset is never updated, so the link always points to the exact version recorded in the link.

EXPLICIT 

The asset isn't updated implicitly, but the user is asked if the link shall point to the latest version if there is a newer version than the one recorded in the link.

IMPLICIT 

The asset is updated implicitly whenever a newer version of the asset exists.

◆ IOTIMEMODE

enum IOTIMEMODE
strong

Requested IoTime.

Enumerator
CREATED 

Creation time of files/directories.

MODIFIED 

Modification time of files/directories.

ACCESSED 

Last access time of files/directories.

◆ URLCOMPARE

enum URLCOMPARE
strong

Flag to pass to Compare.

Enumerator
DEFAULT 

Default comparison mode. Urls are case-sensitive.

NORMALIZE 

Normalizes both operands (via Normalize) before the links are compared with URLCOMPARE::DEFAULT.

IONORMALIZE 

Normalizes both operands (via IoNormalize) before the links are compared with URLCOMPARE::DEFAULT.

LEGACY 

Activates legacy behavior like in C4D which does case-insensitive comparison on Windows and OS X (but not Linux).

FULL 

DEFAULT + compare with all data dictionaries.

◆ IODETECT

enum IODETECT
strong

Return value of IoDetect().

Enumerator
ERRORSTATE 

Error code, e.g. IoHandlerInterface not found.

NONEXISTENT 

Url doesn't exist.

UNKNOWN 

Url is of unknown type.

FILE 

Url is a file.

LINK 

Url is a link.

DIRECTORY 

Url is a directory, you can use GetBrowseIterator to iterate through the children.

◆ OPENSTREAMFLAGS

enum OPENSTREAMFLAGS
strong

Flags for Url::OpenInputStream(), Url::OpenOutputStream(), Url::OpenInOutputStream()

Enumerator
NONE 

No flags set.

WRITE_DONT_TRUNCATE 

Allows to write to existing files without truncation, so the existing file is kept as is.

ALLOW_SHARED_READ_WRITE_ACCESS 

Allows other threads to read / write the file in parallel. The other instance needs to set this flag also. If you open a file for writing WRITE_DONT_TRUNCATE must be specified at the same time. There are certain limitations under OS X and Linux, see FileLocks.

SEEK_TO_END 

Sets the file handle to the end of file after opening. To append to the end of a file use WRITE_DONT_TRUNCATE | SEEK_TO_END.

FULL_DUPLEX 

Allows to open streams (tcp) using full duplex where data can be read and sent simultaneously.

ASK_FOR_REMOVE_WRITE_PROTECTION 

If the file that should be written is write protected the system will ask for checkout/remove flags.

◆ NORMALIZEFLAGS

enum NORMALIZEFLAGS
strong

Flags for Url::Normalize and Url::IoNormalize.

Enumerator
NONE 

Just used for internal purposes. Has no effect when used on a resolve function.

SCHEME_BASED 

If given the scheme decides on his own how the path is resolved. Exclusive flag.

CASE 

The path is put to the canonical form (preferred is lowercase). A given authority is untouched.

PATH_SEGMENT 

Removes . and .. in case they are full path segments.

UNICODE_DECOMPOSITION 

Normalization for unicode decompositions. Only used by OSX file handler, ignored by other implementations and OS.

UNDERLYING 

Resolve Url to underlying Url if possible for 1 level. E.g., an asset Url might get resolved to a file Url.

UNDERLYING_RECURSIVE 

Resolve Url to underlying Url if possible recursive for all levels. E.g., an asset Url might get resolved to a file Url.

◆ IOATTRIBUTES

enum IOATTRIBUTES : UInt
strong

Attributes of Url.

Enumerator
NONE 
READONLY 

Url is read only.

HIDDEN 

Url is hidden.

ARCHIVE 

Url has archive bit set.

LOCKED 

Url is locked (only for Mac, ignored on Windows).

OWNER_R 

Url RWX flags (osx/linux).

OWNER_W 

Url RWX flags (osx/linux).

OWNER_X 

Url RWX flags (osx/linux).

GROUP_R 

Url RWX flags (osx/linux).

GROUP_W 

Url RWX flags (osx/linux).

GROUP_X 

Url RWX flags (osx/linux).

PUBLIC_R 

Url RWX flags (osx/linux).

PUBLIC_W 

Url RWX flags (osx/linux).

PUBLIC_X 

Url RWX flags (osx/linux).

RW_MASK 

Url RW mask (osx/linux).

RWX_MASK 

Url RWX mask (osx/linux).

MASK_ALL 

Masks all attributes, e.g. IoSetAttributes(IoGetAttributes(),IOATTRIBUTES::MASK_ALL).

◆ IOSHOWINOSFLAGS

enum IOSHOWINOSFLAGS
strong

Flags used by Url::IoShowInOS and IoConnection::IoShowInOS.

Enumerator
NONE 

No flags.

SHOW_IN_EXPLORER 

Show the url in the windows explorer or osx finder.

OPEN_IN_EXPLORER 

Open the file using the connected app in the operating system.

◆ MACHINESTATE

enum MACHINESTATE
strong

State of a MachineRef. Various scenarios are possible with connected machines. a) A machine is manually added but also announced via ZeroConf services. b) A machine is added by ZeroConf and established a connection, but afterwards the ZeroConf disappeared and the connection is still online.

Enumerator
NONE 

No bit set.

CONNECTION_ERROR 

A connection error occurred with the machine.

ADDED_MANUALLY 

Flag that signals that the machine is added manually.

AVAILABLE_ZEROCONF 

Flag that signals that the machine is announced via zeroconf and is currently online (not necessary connected).

CONNECTED 

Flag that signals that the machine is currently connected to the local machine.

ALL 

All Flags combined, useful for masking.

◆ NO_VALUE_TYPE

enum NO_VALUE_TYPE
strong

Dummy value to indicate that there is no value.

Enumerator
VALUE 

◆ PARSERFLAGS

enum PARSERFLAGS
strong
Enumerator
NONE 
HAS_NO_EOF 

◆ ACCESSLEVEL

enum ACCESSLEVEL
strong
Enumerator
UNDEFINED 

not defined, invalid setting.

USERINSTALLATION 

settings for this users local installation.

ACCOUNT 

settings for the currently logged-in user.

USER 

settings for the current local user.

MACHINE 

settings for all users of the current machine.

DEFAULTS 

settings of the default value (needs to be initialized on startup)

ALL 

start level of the search through all instances USERINSTALLATION -> ACCOUNT -> USER -> MACHINE -> DEFAULT

◆ EXECUTEPROGRAMFLAGS

enum EXECUTEPROGRAMFLAGS
strong
See also
SystemProcessInterface::StartProcess().
Enumerator
NONE 
CAPTURELOGFILE 

The standard output will be routed into a file.

DONT_DELETE_LOGFILE 

The logfile will not be deleted at the end of the call.

HIDE_APPLICATION 

Starts the application in hidden mode (e.g. suppresses the console window when running under windows).

◆ EXECUTEPROGRAMCALLBACK

See also
SystemProcessInterface::StartProcessAndWait().
Enumerator
STARTED 

Program started regular.

RUNNING 

Program is running, this callback comes every second. return 0 to continue. return 'stop' to kill the running process.

FINISHED 

Program finish.

KILLED 

Program finish with signal kill.

CLEANUP_OK 

Cleanup phase (succeeded case), here the logfile should be deleted!

CLEANUP_FAILED 

Cleanup phase (failed case), here the logfile should be deleted!

◆ WAIT_PROCESS_RESULT

enum WAIT_PROCESS_RESULT
strong

Result of WaitForProcess.

Enumerator
FINISHED 

Process has finished.

RUNNING 

Process is still running.

◆ THREADPRIORITY

enum THREADPRIORITY : Int16
strong
Enumerator
NORMAL 
ABOVE 
BELOW 
LOWEST 
BACKGROUND_IDLE 

◆ WAITMODE

enum WAITMODE
strong

WAITMODE can be optionally specified for almost all objects with a Wait() method. Most of the time you don't have to specify anything and implicitely use the default. You can however specify WAITMODE::RETURN_ON_CANCEL in cases where your job/thread might be cancelled and you don't want it to hang in a Wait() call.

{
// ... your job/ thread code doing something ...
// wait for something (could be a job, thread, group, condition variable ...)
if (something.Wait(TIMEVALUE_INFINITE, WAITMODE::RETURN_ON_CANCEL) == false)
{
// At this point Wait() has returned even though something we waited for has not completed.
// We might have to cancel something for (e.g. if it depends on data owned by this job)
// and wait until it has done so. This looks like the following:
something.Cancel();
// Now wait until it has really cancelled (does not access our data anymore).
something.Wait();
}
// Here you might release whatever data you owned which something was accessing.
}
static constexpr Seconds TIMEVALUE_INFINITE
Definition: timevalue.h:460
@ RETURN_ON_CANCEL
Wait() should return if the caller has been cancelled even though the condition is not set yet.
Enumerator
DEFAULT 

Default case: Wait() will return if the condition is set or it has timed out.

RETURN_ON_CANCEL 

Wait() should return if the caller has been cancelled even though the condition is not set yet.

PRIVATE_BLOCKING 

Wait() won't execute other jobs on the thread while it is waiting (for legacy threads only).

EXTERNAL_ENQUEUE 

Wait() for a job which has been enqueued by a different thread (by default this is not allowed to prevent deadlocks).

DONT_WAIT 

For ExecuteOnMainThread only: Do not wait.

◆ THREADTYPE

enum THREADTYPE
strong
Enumerator
MAIN 

The main thread.

WORKER 

A worker thread of a queue.

STANDALONE 

A standalone thread.

ALIEN 

An alien thread (only limited use of MAXON API allowed).

ASSIMILATED 

An assimilated alien thread (full use of the MAXON API allowed).

◆ BASE_DIMENSION

enum BASE_DIMENSION
strong
Enumerator
LENGTH 
TIME 
MASS 
TEMPERATURE 
AMOUNT_OF_SUBSTANCE 
ELECTRIC_CURRENT 
LUMINOUS_INTENSITY 
ANGLE 
SOLID_ANGLE 
PRIVATE_COUNT 

◆ URLFILECACHEFLAGS

enum URLFILECACHEFLAGS
strong

Flags used by UrlFileCacheInterface::FindOrCreateUrl.

Enumerator
NONE 
FORCE_RELOAD 

Reloads the file from the sourceUrl, a new cache file will be created. The previous cache file will stay until older UrlFileCacheEntries disappear.

◆ ERROR_OK

enum ERROR_OK
strong

A single-valued enum to indicate success of an operation. This is used for comparisons with Result, and for an Error constructor.

Enumerator
VALUE 

The single value of this enum.

◆ ERROR_FAILED

enum ERROR_FAILED
strong

A single-valued enum to indicate failure of an operation. This is used for comparisons with Result.

Enumerator
VALUE 

The single value of this enum.

◆ ERROR_TYPE

enum ERROR_TYPE
strong

This enum is used for CreateError() to indicate the desired error class.

Enumerator
OUT_OF_MEMORY 

Create an OutOfMemoryError.

NULLPTR 

Create a NullptrError.

ILLEGAL_ARGUMENT 

Create an IllegalArgumentError.

ILLEGAL_STATE 

Create an IllegalStateError.

NOT_IMPLEMENTED 

Create a FunctionNotImplementedError.

UNRESOLVED 

Create an UnresolvedError.

UNKNOWN 

Create an UnknownError.

◆ WIRE_MODE

enum WIRE_MODE : UChar
strong

WIRE_MODE is used for the wires in a Wires object to control whether a wire is set, inherited or hidden.

This is an ordered enumeration with NONE < MIN < NORMAL < MAX. Other values shouldn't be used for ordered comparisons.

See also
Wires
Enumerator
NONE 

No wire.

MIN 

A wire with minimum priority.

NORMAL 

A wire with normal priority.

PROPAGATION 

A wire with propagation priority.

AUTO_PROPAGATION 

A wire with auto-propagation priority.

MAX 

A wire with maximum priority.

REMOVE 

Only used for MutablePort::Connect to tell that the an existing wire shall be removed.

ALL 

A mask for all explicit modes.

FLAG0 

A wire flag which can be used for wires which don't interpret the wire mode as priority, but as a bit set. Different from NORMAL and any other flag in WIRE_MODE.

FLAG1 

A wire flag which can be used for wires which don't interpret the wire mode as priority, but as a bit set. Different from NORMAL and any other flag in WIRE_MODE.

IMPLICIT 

Used as mask for implicit wires in MutablePort::GetConnections.

ALL_INCLUDING_IMPLICIT 

A mask for all modes.

INHERIT 

Used for MutablePort::Connect to tell that the wire mode shall be inherited. (Also used internally.)

FLAGS_MASK 

Mask for FLAG0 | FLAG1.

FULL_MASK 

Complete mask for all bits of WIRE_MODE.

CONNECT_DEFAULT 

Default mode for Connect methods.

GETCONNECTIONS_DEFAULT 

Default mode for GetConnections methods.

◆ CONNECTION_POSITION

enum CONNECTION_POSITION
strong

Graph connections can store attribute values at three different positions: At their source, at their center and at their target.

Enumerator
SOURCE 

The source position of a connection.

CENTER 

The center position of a connection.

TARGET 

The target position of a connection.

◆ NODE_KIND

enum NODE_KIND
strong

NODE_KIND allows to determine whether a general node (g-node for short) is a true node, a port or a port list. Because nodes, ports and port lists can be represented in a single hierarchy, classes such as GraphNode and GNode make use of this and need NODE_KIND to determine the actual kind of a g-node.

  • NODE stands for true nodes. They may contain nested nodes and two port lists, one for the input ports and one for the output ports.
  • INPUTS and OUTPUTS stand for port lists. They occur in the hierarchy as direct children of true nodes. Each true node may have at most one input list and one output list.
  • INPORT and OUTPORT stand for ports. When a port is actually a port bundle, it may contain nested ports. A port is a child of either a port bundle or a port list.
Enumerator
NONE 

Special value used e.g. for null references.

NODE 

Indicates that the g-node is a true node.

INPUTS 

Indicates that the g-node is an input port list. An input port list has a true node as parent and input ports as children.

OUTPUTS 

Indicates that the g-node is an output port list. An output port list has a true node as parent and output ports as children.

INPORT 

Indicates that the g-node is an input port. An input port has an input port list or an input port as parent and input ports as children.

OUTPORT 

Indicates that the g-node is an output port. An output port has a output port list or a output port as parent and output ports as children.

IN_MASK 

Mask to check a NODE_KIND if it stands for an input port or an input port list.

OUT_MASK 

Mask to check a NODE_KIND if it stands for an output port or an output port list.

PORTLIST_MASK 

Mask to check a NODE_KIND if it stands for a port list.

PORT_MASK 

Mask to check a NODE_KIND if it stands for a port.

ALL_MASK 

Mask which matches all node kinds.

◆ COLORPROFILEINFO

enum COLORPROFILEINFO
strong

Return value of ColorProfile.GetInfo() function.

Enumerator
DESCRIPTION 

Description of the color profile.

MANUFACTURER 

Manufacturer of the color profile.

MODEL 

Model of the color profile.

COPYRIGHT 

Copyright information of the color profile.

NAME 

Name of the color profile.

OCIO_CONFIG_PATH 

Full path to the OCIO config file (empty if this is not an OCIO colorspace)

◆ COLORCONVERSIONINTENT

enum COLORCONVERSIONINTENT
strong

Color Conversion intent. This value controls the intent of the color conversion. Members docs copied from http://www.littlecms.com/LittleCMS2.6%20tutorial.pdf

Enumerator
PERCEPTUAL 

Hue hopefully maintained (but not required), lightness and saturation sacrificed to maintain the perceived color. White point changed to result in neutral grays. Intended for images.

RELATIVE_COLORIMETRIC 

Within and outside gamut; same as Absolute Colorimetric. White point changed to result in neutral grays.

SATURATION 

Hue and saturation maintained with lightnesssacrificed to maintain saturation. White point changed to result in neutral grays. Intended for business graphics (make it colorful charts, graphs, overheads, ...)

ABSOLUTE_COLORIMETRIC 

Within the destination device gamut; hue, lightness and saturation are maintained. Outside the gamut; hue and lightness are maintained, saturation is sacrificed. White point for source and destination; unchanged. Intended for spot colors (Pantone, TruMatch, logo colors, ...)

◆ COLORCONVERSIONFLAGS

enum COLORCONVERSIONFLAGS
strong

Color Conversion intent. This value controls the intent of the color conversion. Members docs copied from http://www.littlecms.com/LittleCMS2.6%20tutorial.pdf

Enumerator
NONE 
BLACKPOINTCOMPENSATION 

Black Point Compensation (BPC) controls whether to adjust for differences in black points when converting colors between color spaces. When Black Point Compensation is enabled, color transforms map white to white and luminance of black to luminance of black. The black point compensation feature does work better in conjunction with relative colorimetric intent. Perceptual intent should make no difference, although it may affect some (wrong) profiles.

INVERSE_DIRECTION 

◆ LAYERSETMODE

enum LAYERSETMODE
strong
Enumerator
LAYERS 

Layers / layer Sets.

LAYERMASKS 

Layer masks.

ALPHAS 

Alpha channels.

LAYERALPHA 

Layer alpha.

DISABLED 

Disabled.

◆ MEDIAFORMATTYPE

enum MEDIAFORMATTYPE
strong

MEDIAFORMAT::IMAGE::TYPE specifies the meaning of the stream.

Enumerator
UNDEFINED 

Must never happen! This value should not be used and should never appear.

IMAGE 

This is the image resource of the stream. This could be the only one in the stream.

ALPHA 

Declares the stream to be interpreted as the alpha channel of the parent stream. This stream must be inserted under a MEDIAFORMATTYPE::IMAGE.

LAYERFOLDER 

Declares the stream to be interpreted as a group layer of the parent stream. This stream must be inserted under a MEDIAFORMATTYPE::IMAGE or another MEDIAFORMATTYPE::LAYERFOLDER.

LAYER 

Declares the stream to be interpreted as a layer of the parent stream. This stream must be inserted under a MEDIAFORMATTYPE::IMAGE or another MEDIAFORMATTYPE::LAYERGROUP.

LAYERADJUSTMENT 

Declares the stream to be interpreted as a adjustment layer of the parent stream. This stream must be inserted under a MEDIAFORMATTYPE::IMAGE or another MEDIAFORMATTYPE::LAYERFOLDER.

LAYERMASK 

Declares the stream to be interpreted as a layer mask of the parent stream. This stream must be inserted under a MEDIAFORMATTYPE::LAYER, MEDIAFORMATTYPE::LAYERADJUSTMENT or MEDIAFORMATTYPE::LAYERFOLDER.

MIPMAP 

Declares the stream to be interpreted as mipmap of the parent stream. This stream must be inserted under a MEDIAFORMATTYPE::IMAGE.

DEEPIMAGEDATA 

Declares the stream to be interpreted as a deep image data. This stream must be inserted under a MEDIAFORMATTYPE::IMAGE.

◆ MEDIAALPHATYPE

enum MEDIAALPHATYPE
strong

MEDIAFORMAT::IMAGE::ALPHATYPE specifies the meaning of the stream.

Enumerator
UNDEFINED 

Undefined.

PREMULTIPLIED 

The alpha is related to premultiplied rgb data.

STRAIGHT 

The alpha is related to straight rgb data.

◆ RLACHANNELS

enum RLACHANNELS
strong
Enumerator
MATERIALID 
NODE_ID 
UV 
NORMAL 
REALPIX 
COVERAGE 
BG 
NODE_RENDER_ID 
COLOR 
TRANSP 
VELOC 
WEIGHT 
MASK 
MAXCOUNT 

◆ RLAFLAGS

enum RLAFLAGS
strong
Enumerator
NONE 

None.

Z.

MATERIALID 

MATERIALID.

OBJECTBUFFER 

Object buffer.

UV 

UV coordinates.

NORMAL 

Normals.

ORIGCOLOR 

Non-clamped color.

COVERAGE 

Coverage.

BG 

BG.

OBJECTID 

Object ID.

COLOR 

Color.

TRANSPARENCY 

Transparency.

SUBPIXEL_WEIGHT 

Sub-pixel weight.

SUBPIXEL_MASK 

Sub-pixel mask.

◆ SELECTIONHANDLERRESULT

Result type of the MediaOutputSelectionHandler.

Enumerator
NONE 
STRUCTURE 

load the image structure (e.g. layers, folders) but create only the layers.

CONTENT_FLAG 

load the image/layer data.

STRUCTURE_WITH_CONTENT 

load the image structure and load the image/layer data.

ALL 

load all (e.g. like no filter would be set).

◆ MEDIASESSIONFLAGS

enum MEDIASESSIONFLAGS
strong
Enumerator
NONE 
RUNONLYANALYZE 

run only the analyze but not the execute pass.

FORCELOAD 

loads the image even if it's already loaded.

◆ BLEND_MODES

enum BLEND_MODES
strong
Enumerator
ADD 
AVERAGE 
COLOR 
COLORBURN 
COLORDODGE 
DARKEN 
DARKER 
DIFFERENCE 
DISSOLVE 
DIVIDE 
EXCLUSION 
FREEZE 
GLOW 
HARDLIGHT 
HARDMIX 
HEAT 
HUE 
HYPOT 
LEVR 
LIGHTEN 
LIGHTER 
LINEARBURN 
LINEARDODGE 
LUMINANCE 
MULTIPLY 
OVER 
OVERLAY 
PINLIGHT 
REFLECT 
SATURATION 
SCREEN 
SOFTLIGHT 
SUBTRACT 
VIVIDLIGHT 
XOR 
PASSFOLDER 
STAMP 

◆ ANIMBLENDSTATE

enum ANIMBLENDSTATE
strong

Parameter used in the ObservableAnimation of the BlendTweenInterface.

Enumerator
NONE 
STARTED 

Optional signal that the animation started. This flags arrives only if duration is != 0.

RUNNING 

Optional signal that the animation is running within some in between state.

FINISHED 

Signals that the animation reached the final state, this state is guaranteed.

CANCELED 

The Animation has been canceled.

◆ FFT_FLAGS

enum FFT_FLAGS
strong

Flags for the FFT transform.

Enumerator
NONE 
CALC_INVERSE 

If set, the reverse transformation from frequency domain to time domain is computed.

SUPPRESS_PADDING 

Suppress automatic padding. Note: Most implementations run faster if the input array count is even or a power of 2. But padding changes the output array count and fills the remaning array entries with zeros. This leads to a slightly different output since padding with zeros in the time domain effectively means interpolating in the frequency domain. For some critical applications it might be advisable to leave the original array size intact. Works only if the implementation supports this feature, otherwise the flag is ignored.

◆ FFT_SUPPORT

enum FFT_SUPPORT
strong

Flags for GetSupportOptions()

Enumerator
NONE 
TRANSFORM_1D 

Component supports 1D transformation.

TRANSFORM_2D 

Component supports 2D transformation.

ALWAYS_PADDING 

If set component always does padding of the input array (e.g. power of 2).

◆ NURBSCURVE_CONTINUITY

enum NURBSCURVE_CONTINUITY
strong
Enumerator
OPEN 

Open spline with No continuity between first and last point.

CLOSED 

Closed spline with position continuity (sharp cusp) between first and last point. Replaces any previous knot vector with a clamped uniform knot vector.

PERIODIC 

Closed spline with C2 continuity between first and last point. Replaces any previous knot vector with an unclamped uniform knot vector.

◆ NURBSCURVE_KNOTMODE

enum NURBSCURVE_KNOTMODE
strong
Enumerator
CLAMPED_UNIFORM 

Clamped uniform (open uniform / quasi uniform) NURBS/B-Spline/Bezier knot vector with end knots of multiplicity of degree. Internal knots are uniform e.g. [0, 0, 0, 1/3, 2/3, 1, 1, 1]. If there are no internal knots then the spline is equal to a bezier spline of same degree e.g. [0, 0, 0, 0, 1, 1, 1, 1].

CLAMPED_CHORDAL 

Clamped nonuniform knot vector whose inner knots are computed according to the actual position of control points in space according to the chord length method. Works only correct if SetPoints has been called before since the routines needs to compute the point distances.

CLAMPED_CENTRIPETAL 

Clamped nonuniform knot vector whose inner knots are computed according to the actual position of control points in space according to the centripetal method.Works only correct if SetPoints has been called before since the routines needs to compute the point distances.

UNCLAMPED_UNIFORM 

uniform knot vector e.g. [0.0, 0.25, 0.5, 0.75, 1.0]. Mostly useful for periodic (closed) splines

USER_DEFINED 

Arbitrary knot vector, supplied by the user.

◆ PRIMITIVETYPE

enum PRIMITIVETYPE
strong
Enumerator
NONE 
POINT 
EDGE 
POLYGON 

◆ CORENODE_PORT_FLAGS

enum CORENODE_PORT_FLAGS
strong

PORT_FLAGS indicates the status of each port of a CoreNode when invoking it with parameters. Some ports can be unconnected, we have to pass proper flags so the node knows which inputs are supplied and which outputs are needed.

Enumerator
NONE 
INPUT_WITHOUT_VALUE 
OUTPUT_UNUSED 

◆ PORT_DIR

enum PORT_DIR : Int
strong

PORT_DIR indicates the kind of a port or the direction of a connection:

  • PORT_DIR::INPUT stands for an input port or an incoming connection (from a source).
  • PORT_DIR::OUTPUT stands for an output port or an outgoing connection (to a target).

To support loops over those two directions, there are the special values BEGIN and END:

for (PORT_DIR dir = PORT_DIR::BEGIN; dir != PORT_DIR::END; ++dir)
{
}
PORT_DIR
Definition: graph_basics.h:34
@ BEGIN
The start value (inclusive) for a loop over port directions.
@ END
The end value (exclusive) for a loop over port directions.
Enumerator
INPUT 

Input direction, i.e., an input port or an incoming connection.

OUTPUT 

Output direction, i.e., an output port or an outgoing connection.

BEGIN 

The start value (inclusive) for a loop over port directions.

END 

The end value (exclusive) for a loop over port directions.

◆ IOFORMAT

enum IOFORMAT
strong
Enumerator
DEFAULT 
BINARY 
BINARY_COMPRESSED 
JSON 
XML 
JSON_STABLE 

This format is identical to JSON but resolves all references on writing and sorts sets and maps so the order stays stable. JSON_STABLE does not support writing of WeakRefs to COW objects.

◆ PROFILER_POINT_TYPE

enum PROFILER_POINT_TYPE
strong

Internal. Defines the type of a profiling point.

Enumerator
NONE 

Unspecified.

METHOD_ENTER 

Enter Method Scope.

METHOD_LEAVE 

Leave Method Scope.

SCOPE_ENTER 

Enter Scope.

SCOPE_LEAVE 

Leave Scope.

DELTA 

Delta From Last Visited Point.

◆ PROFILER_STATE

enum PROFILER_STATE
strong

Internal. Defines the profiler state.

Enumerator
DISABLED 

Disabled.

ENABLED_METHOD_SCOPE 

Enabled for METHOD_ENTER and METHOD_LEAVE point types.

ENABLED_ALL 

Enabled for all point types.

◆ PROFILER_CLOCK_MODE

enum PROFILER_CLOCK_MODE
strong

Internal. Defines the profiler clock mode.

Enumerator
NORMAL 

Use the system clock.

SIMULATED 

Use a simulated clock for profiling purpose.

◆ SELECTION_MODE

enum SELECTION_MODE : UChar
strong

Selection Modifier.

Enumerator
NEW 

new selection - needs reset of all previously existing selections

ADD 

add to selection

SUBTRACT 

subtract selection

TOGGLE 

toggle selection

◆ SELECTION_STATUS

enum SELECTION_STATUS : UChar
strong

Selection status.

Enumerator
NONE 

no selection at all

SELECTED 

item (e.g. widget/presenter) is selected

IMPLICIT 

item (e.g. widget/presenter) is implicitly selected

◆ GEOMETRY_TEST_EXACT

enum GEOMETRY_TEST_EXACT
strong

Return type for geometric tests when degenerate cases need to be reported.

Enumerator
GEOM_FALSE 

Test result is false.

GEOM_TRUE 

Test result is true.

GEOM_PARALLEL 

Degenerate colinear, ordered in same direction.

GEOM_ANTIPARALLEL 

Degenerate colinear, ordered in opposite direction.

GEOM_COINCIDENT_PREV 

Degenerate coincident points.

GEOM_COINCIDENT_NEXT 

Degenerate coincident points.

GEOM_COINCIDENT_ALL 

Degenerate coincident points.

GEOM_DEGENERATE 

Other degeneracy.

GEOM_INVALID_INPUT 

Input is non-valid in some way making it impossible to proceed.

◆ LOOP_OVERLAP_STATE

enum LOOP_OVERLAP_STATE
strong

Return type for loop overlap state queries.

Enumerator
INTERSECTING 

Loops intersect each other. Contact points do not count as intersections, only actual crossings of the loops.

DISJOINT 

Loops are completely disjoint from each other.

A_INSIDE_B 

A is entirely within B.

B_INSIDE_A 

B is entirely within A.

COINCIDENT 

Loops are coincident - they lie on each other's perimeter, e.g. A and B are the same.

DEGENERATE 

At least one of A and B has insufficient vertices (need at least 3)

◆ HTTPCODE

enum HTTPCODE
strong

Return codes for http functions.

Enumerator
CLOSED 

the connection has been closed.

FINISHED 

the request has been completed.

CALL_NEXT_HANDLER 

the request was not processed by this message handler, continue with the next one.

PROXYERROR 

a proxy configuration error

OK 

return a http okay.

POST 

return a http post.

MOVED 

"301 Moved Permanently". the requested file has been moved. check the header "location" entry to get the new location.

SYNTAX 

return a http syntax error.

AUTH 

return a http authentication error.

ACCESS 

return a http access error.

NOTFOUND 

return a http file not found error.

PROXYAUTHENTICATIONREQUIRED 

a connection requires proxy authentication

INTERNAL 

return a http internal error.

UNKNOWN 

return a http unknown error.

GATEWAYTIMEOUT 

return a http gateway timeout error.

◆ SOCKETMODE

enum SOCKETMODE
strong
Enumerator
READ 
WRITE 
LISTEN 
CONNECT 

◆ CONNECTIONMODE

enum CONNECTIONMODE
strong
Enumerator
UNDEFINED 
SEND 
READ 

◆ CONNECTIONTYPE

enum CONNECTIONTYPE
strong
Enumerator
LISTENER 
INCOMING 
OUTGOING 

◆ PROTOCOL

enum PROTOCOL
strong

Defines the type of an IP address used by NetworkIpAddrInterface.

Enumerator
UNSPEC 

Unspecified.

IPV4 

IPV4 address.

IPV6 

IPV6 address.

◆ WILDCARD_IPV4_ADDRESS_TYPE

Any IPv4 address. Equivalent to INADDR_ANY.

Enumerator
VALUE 

◆ WILDCARD_IPV6_ADDRESS_TYPE

Any IPv6 address. Equivalent to in6addr_any.

Enumerator
VALUE 

◆ SSLSOCKETTYPE

enum SSLSOCKETTYPE
strong
Enumerator
CLIENTCONNECTION 
SERVERCONNECTION 

◆ SSLPROTOCOLVERSION

enum SSLPROTOCOLVERSION
strong

Defines possible ssl protocol versions.

Enumerator
TLS1 

use TLS1.

TLS11 

use TLS1.1.

TLS12 

use TLS1.2.

TLS 

use newest TLS version.

◆ SSLCERTREQUIREMENTS

enum SSLCERTREQUIREMENTS
strong

Defines possible ssl certificate verification options.

Enumerator
NONE 

mode: no certificate is required.

ISOPTIONAL 

mode: a certificate is optional. If this flag is set you need to deliver a valid caCertsFile file in the SSLNetworkConnectionInterface::Init() function.

ISREQUIRED 

mode: a server certificate is required and need to have a valid ca root. If this flag is set you need to deliver a valid caCertsFile file in the SSLNetworkConnectionInterface::Init() function.

MODE 
VERIFY_AUTHORITY 

flag: verifies the server certificate with the given url. if the server authority pattern doesn't match an error is returned in the handshake.

◆ SSLFILETYPE

enum SSLFILETYPE
strong
Enumerator
ASN1 
PEM 

◆ OAUTHSIGNATUREMETHOD

enum OAUTHSIGNATUREMETHOD
strong
Enumerator
NONE 
PLAINTEXT 
HMAC_SHA1 

◆ OAUTHHTTPMETHOD

enum OAUTHHTTPMETHOD
strong
Enumerator
NONE 
GET 
POST 

◆ OAUTHERRORCODE

enum OAUTHERRORCODE
strong
Enumerator
NO_USERACCOUNT 
SERVICE_NOT_AVAILABLE 

◆ HTTPMETHOD

enum HTTPMETHOD
strong
Enumerator
GET 
POST 
PUT 
DELETE 

◆ HTTPREQUESTTYPE

enum HTTPREQUESTTYPE
strong
Enumerator
UNKNOWN 
GET 
POST 

◆ WEBSOCKETSTATE

enum WEBSOCKETSTATE
strong
Enumerator
NOT_CONNECTED 

connection is not established yet.

CONNECTED 

connection is established.

CLOSED 

connection is closed. Sending data is not allowed anymore.

ERROR 

connection is in error state, so it's going to be closed.

◆ WEBSOCKETTYPE

enum WEBSOCKETTYPE
strong

Used by NetworkWebSocketConnectionInterface::Send().

Enumerator
TEXT 

text WebSocket frame.

BINARY 

binary WebSocket frame.

CLOSE 

◆ WEBSOCKET_OPCODE

enum WEBSOCKET_OPCODE : UChar
strong

WebSockets opcodes. See https://tools.ietf.org/html/rfc6455 for details.

Enumerator
CONTINUE 

continuation frame, no data follows

TEXT 

text frame

DATA 

binary frame

CLOSE 

closing frame

PING 

ping frame

PONG 

pong frame

ILLEGAL 

invalid state

◆ ZEROCONFACTION

enum ZEROCONFACTION
strong
Enumerator
NONE 
RESOLVE 
MONITOR 

◆ ZEROCONFMACHINESTATE

enum ZEROCONFMACHINESTATE
strong
Enumerator
ONLINE 
OFFLINE 
REMOVED 
UPDATE 

◆ ZEROCONFERROR

enum ZEROCONFERROR
strong
Enumerator
NONE 
UNKNOWN 
NOSUCHNAME 
NOMEMORY 
BADPARAM 
BADREFERENCE 
BADSTATE 
BADFLAGS 
UNSUPPORTED 
NOTINITIALIZED 
ALREADYREGISTERED 
NAMECONFLICT 
INVALID 
FIREWALL 
INCOMPATIBLE 
BADINTERFACEINDEX 
REFUSED 
NOSUCHRECORD 
NOAUTH 
NOSUCHKEY 
NATTRAVERSAL 
DOUBLENAT 
BADTIME 
BADSIGNAL 
BADKEY 
TRANSIENT 
SERVICENOTRUNNING 
NATPORTMAPPINGUNSUPPORTED 
NATPORTMAPPINGDISABLED 
NOROUTER 
POLLINGMODE 

◆ NIMBUS_PATH

enum NIMBUS_PATH
strong

NIMBUS_PATH is used as argument for NimbusBaseInterface::GetPath and NimbusBaseInterface::SetPath.

Enumerator
STARTNODE 

Path of the node initially shown in the Attributes Manager.

SOLO 

Path of the node or port used for solo mode.

MATERIALENDNODE 

Path of the material end node.

◆ PyStringEncodings

enum PyStringEncodings
strong
Enumerator
Utf8 
Utf16 
Utf32 
PyDecode 

◆ OWNERSHIP

enum OWNERSHIP
strong
Enumerator
NORMAL 
CALLER 

Default ownership.

CALLEE 

Caller owns the object.

CALLER_BUT_COPY 

Callee owns the object.

◆ Errno

enum Errno : int
strong
Enumerator
_EPERM 
_ENOENT 
_ESRCH 
_EINTR 
_EIO 
_ENXIO 
_E2BIG 
_ENOEXEC 
_EBADF 
_ECHILD 
_EAGAIN 
_ENOMEM 
_EACCES 
_EFAULT 
_ENOTBLK 
_EBUSY 
_EEXIST 
_EXDEV 
_ENODEV 
_ENOTDIR 
_EISDIR 
_EINVAL 
_ENFILE 
_EMFILE 
_ENOTTY 
_ETXTBSY 
_EFBIG 
_ENOSPC 
_ESPIPE 
_EROFS 
_EMLINK 
_EPIPE 
_EDOM 
_ERANGE 
_EDEADLK 
_ENAMETOOLONG 
_ENOLCK 
_ENOSYS 
_ENOTEMPTY 
_ELOOP 
_EWOULDBLOCK 
_ENOMSG 
_EIDRM 
_ECHRNG 
_EL2NSYNC 
_EL3HLT 
_EL3RST 
_ELNRNG 
_EUNATCH 
_ENOCSI 
_EL2HLT 
_EBADE 
_EBADR 
_EXFULL 
_ENOANO 
_EBADRQC 
_EBADSLT 
_EDEADLOCK 
_EBFONT 
_ENOSTR 
_ENODATA 
_ETIME 
_ENOSR 
_ENONET 
_ENOPKG 
_EREMOTE 
_ENOLINK 
_EADV 
_ESRMNT 
_ECOMM 
_EPROTO 
_EMULTIHOP 
_EDOTDOT 
_EBADMSG 
_EOVERFLOW 
_ENOTUNIQ 
_EBADFD 
_EREMCHG 
_ELIBACC 
_ELIBBAD 
_ELIBSCN 
_ELIBMAX 
_ELIBEXEC 
_EILSEQ 
_ERESTART 
_ESTRPIPE 
_EUSERS 
_ENOTSOCK 
_EDESTADDRREQ 
_EMSGSIZE 
_EPROTOTYPE 
_ENOPROTOOPT 
_EPROTONOSUPPORT 
_ESOCKTNOSUPPORT 
_EOPNOTSUPP 
_EPFNOSUPPORT 
_EAFNOSUPPORT 
_EADDRINUSE 
_EADDRNOTAVAIL 
_ENETDOWN 
_ENETUNREACH 
_ENETRESET 
_ECONNABORTED 
_ECONNRESET 
_ENOBUFS 
_EISCONN 
_ENOTCONN 
_ESHUTDOWN 
_ETOOMANYREFS 
_ETIMEDOUT 
_ECONNREFUSED 
_EHOSTDOWN 
_EHOSTUNREACH 
_EALREADY 
_EINPROGRESS 
_ESTALE 
_EUCLEAN 
_ENOTNAM 
_ENAVAIL 
_EISNAM 
_EREMOTEIO 
_EDQUOT 
_ENOMEDIUM 
_EMEDIUMTYPE 
_ECANCELED 
_ENOKEY 
_EKEYEXPIRED 
_EKEYREVOKED 
_EKEYREJECTED 
_EOWNERDEAD 
_ENOTRECOVERABLE 

◆ CONTAINS

enum CONTAINS : int
strong
Enumerator
_FOUND 
_NOTFOUND 
_ERROR 

◆ VMSETTINGS

enum VMSETTINGS
strong
Enumerator
MOVE_ERRORS_TO_RESULT 
USE_AUTO_GIL 

◆ VMINITSETTINGS

enum VMINITSETTINGS
strong
Enumerator
CPYTHON_ADDITIONAL_SYS_PATH 

maxon::Url

CPYTHON_INTERPRETERFLAGS 

py::PYTHONFLAG

CPYTHON_SUBINTERPRETER 

Bool.

PYPY_EXECUTABLE 

Private.

◆ ERRORHANDLING

enum ERRORHANDLING
strong
Enumerator
PRINT 

Any thrown exception will be handled internally.

CLEAR 

Any thrown exception will be cleared automatically.

REDIRECT 

Any thrown exception will result in a corresponding maxon.Error. The internal error state of the virtual machine is untouched.

◆ DEFAULTRUNTIME

enum DEFAULTRUNTIME
strong
Enumerator
NONE 
DEBUG_3_VS2015 
RELEASE_3_VS2015 
DEBUG_3 
RELEASE_3 
DEFAULT_3 
DEFAULT 

◆ LINEXECUTION

enum LINEXECUTION
strong

Return value for LineDelegate. Used to control execute or skip the given operation.

Enumerator
RUN 
SKIP 

◆ GRIDTYPE

enum GRIDTYPE
strong

Volume Types.

Enumerator
NONE 
FLOAT 
DOUBLE 
INT32 
INT64 
INTVECTOR32 
VECTOR32 
VECTOR64 
STRING 
BOOLEAN 

◆ GRIDCLASS

enum GRIDCLASS
strong

Volume Classes.

Enumerator
NONE 
SDF 
FOG 
STAGGERED 
UNKNOWN 

◆ VECTORGRIDTYPE

enum VECTORGRIDTYPE
strong

Vector Volume Types.

Enumerator
INVARIANT 
COVARIANT 
COVARIANT_NORMALIZE 
CONTRAVARIANT_RELATIVE 
CONTRAVARIANT_ABSOLUTE 

◆ NANOVDBPRECISION

enum NANOVDBPRECISION
strong
Enumerator
FP4 
FP8 
FP16 
FPN 
FLOAT 

◆ VOLUMESAMPLER

enum VOLUMESAMPLER
strong
Enumerator
NEAREST 
LINEAR 
QUADRATIC 

◆ ITERATORTYPE

enum ITERATORTYPE
strong
Enumerator
ALL 
ON 
OFF 

◆ TREEVOXELLEVEL

enum TREEVOXELLEVEL
strong
Enumerator
ROOT 
TWO 
THREE 
LEAF 

◆ VOLUME_RAY_TYPE

enum VOLUME_RAY_TYPE
strong
Enumerator
WORLD_SPACE 

world space

INDEX_SPACE 

index space

◆ POLYGONCONVERSIONFLAGS

Enumerator
NONE 
UNSIGNED_DISTANCE_FIELD 
DISABLE_INTERSECTING_VOXEL_REMOVAL 
DISABLE_RENORMALIZATION 
DISABLE_NARROW_BAND_TRIMMING 

◆ MIXVECTORTYPE

enum MIXVECTORTYPE
strong
Enumerator
NONE 
NORMAL 
ADD 
SUBTRACT 
CROSS 

◆ SDFFILTERTYPE

enum SDFFILTERTYPE
strong
Enumerator
NONE 
GAUSSIAN 
DILATE 
ERODE 
MEANVALUE 
MEDIANVALUE 
MEANCURVATURE 
LAPLACIANFLOW 
RENORMALIZE 
OPEN 
CLOSE 
TRACK 
RESIZE 

◆ FILTERTYPE

enum FILTERTYPE
strong
Enumerator
NONE 
GAUSSIAN 
MEANVALUE 
MEDIANVALUE 
ADD 
REMAP 
CURVEREMAP 
MULTIPLY 
ABS 
INVERT 

◆ VECTORFILTERTYPE

enum VECTORFILTERTYPE
strong
Enumerator
NONE 
GAUSSIAN 
MEANVALUE 
MEDIANVALUE 
CURL 
NORMALIZE 
INVERT 
SCALE 
ROTATE 

◆ FILTERACCURACY

enum FILTERACCURACY
strong
Enumerator
NONE 
FIRST 
SECOND 
THIRD 
WENO5 
HJWENO5 

◆ BOOLTYPE

enum BOOLTYPE
strong
Enumerator
NONE 
UNION 
DIFF 
INTERSECT 

◆ MIXTYPE

enum MIXTYPE
strong
Enumerator
NONE 
NORMAL 
MAX 
MIN 
ADD 
SUBTRACT 
MULTIPLY 
DIVIDE 

◆ RESAMPLEINTERPOLATIONTYPE

Enumerator
NONE 
NEAREST 
LINEAR 
QUADRATIC 

◆ FIELDLAYER_FLAG

enum FIELDLAYER_FLAG
strong
Enumerator
NONE 

Default state.

SKIP 

Layer calculation is disabled, e.g. the linked object on a standard layer's deform mode is false.

HIDE 

Layer should be completely ignored from both calculation and GUI display, e.g. the linked object has been deleted.

MODIFYDATA 

The layer modifies existing data and needs the values from layers beneath it in the layerlist in the "results" array inside of Sample.

PRESERVEALPHA 

The layer doesn't adjust the existing alpha and it's color changes should be applied ignoring any alpha values.

NOCHILDVALUE 

Children of this layer wont output their value.

NOCHILDCOLOR 

Children of this layer wont output their color.

NOCHILDDIRECTION 

Children of this layer wont output their direction.

TEMPORARY 

Don't save this layer with the list or duplicate it (outside of undo)

NOCHILDROTATION 

Children of this layer wont output their direction.

Function Documentation

◆ MAXON_REGISTRY() [1/64]

maxon::MAXON_REGISTRY ( Class< AutoWeightRef >  ,
AutoWeightAlgos  ,
"net.maxon.animation.registry.autoweights"   
)

◆ MAXON_ENUM_LIST() [1/113]

enum maxon::ASSETBROWSERMODE maxon::MAXON_ENUM_LIST ( ASSETBROWSERMODE  )

◆ MAXON_ENUM_LIST() [2/113]

enum maxon::ASSETGROUPBY maxon::MAXON_ENUM_LIST ( ASSETGROUPBY  )

◆ MAXON_ENUM_LIST() [3/113]

enum maxon::ASSETSORTBY maxon::MAXON_ENUM_LIST ( ASSETSORTBY  )

◆ MAXON_ENUM_LIST() [4/113]

enum maxon::ASSETSORTFIRST maxon::MAXON_ENUM_LIST ( ASSETSORTFIRST  )

◆ MAXON_ENUM_LIST() [5/113]

enum maxon::ASSETSORTORDER maxon::MAXON_ENUM_LIST ( ASSETSORTORDER  )

◆ MAXON_ENUM_LIST() [6/113]

enum maxon::ASSETRELEVANCECONTEXT maxon::MAXON_ENUM_LIST ( ASSETRELEVANCECONTEXT  )

◆ MAXON_ENUM_FLAGS() [1/34]

enum maxon::REPOSITORYSTATE maxon::MAXON_ENUM_FLAGS ( REPOSITORYSTATE  )

◆ MAXON_ENUM_LIST() [7/113]

enum maxon::FILTERASSETRESULT maxon::MAXON_ENUM_LIST ( FILTERASSETRESULT  )

◆ MAXON_ENUM_LIST() [8/113]

enum maxon::MASTERFILTER maxon::MAXON_ENUM_LIST ( MASTERFILTER  )

◆ MAXON_ENUM_LIST() [9/113]

enum maxon::LENGTHUNITSYSTEM maxon::MAXON_ENUM_LIST ( LENGTHUNITSYSTEM  )

◆ MAXON_ENUM_LIST() [10/113]

enum maxon::BUILDBROWSERENTRYCOMMAND maxon::MAXON_ENUM_LIST ( BUILDBROWSERENTRYCOMMAND  )

◆ MAXON_DATATYPE() [1/73]

maxon::MAXON_DATATYPE ( AssetDatabaseStruct  ,
"net.maxon.datatype.assetdatabasestruct"   
)

◆ MAXON_ENUM_LIST() [11/113]

enum maxon::DOWNLOADSTATE maxon::MAXON_ENUM_LIST ( DOWNLOADSTATE  )

◆ MAXON_DATATYPE() [2/73]

maxon::MAXON_DATATYPE ( DragAndDropDataAssetArray  ,
"net.maxon.datatype.draganddropdataassetarray"   
)

◆ MAXON_REGISTRY() [2/64]

maxon::MAXON_REGISTRY ( AssetRenaming  ,
AssetRenamings  ,
"net.maxon.registry.assetrenamings"   
)

Registry of all AssetRenaming delegates.

Asset repositories ask all registered AssetRenaming delegates for identifier changes whenever one of their find functions is called. The result of the first delegate which returns a renaming is used.

◆ MAXON_FORWARD() [1/2]

class DataDescription maxon::MAXON_FORWARD ( "maxon/datadescription.h"  )

◆ MAXON_FORWARD() [2/2]

class DataDescriptionDefinition MAXON_FORWARD ( "maxon/datadescriptiondefinition.h"  )

◆ MAXON_ENUM_FLAGS() [2/34]

enum maxon::ASSETLICENSETYPE UInt64 maxon::MAXON_ENUM_FLAGS ( ASSETLICENSETYPE  )

◆ MAXON_DATATYPE() [3/73]

maxon::MAXON_DATATYPE ( AssetDependencyStruct  ,
"net.maxon.datatype.asset.dependencystruct"   
)

◆ MAXON_DECLARATION() [1/89]

maxon::MAXON_DECLARATION ( Class< AssetType >  ,
AssetTypeBaseComponent  ,
"net.maxon.component.assettypebase"   
)

This base component can be used by implementations of AssetType.

◆ MAXON_REGISTRY() [3/64]

maxon::MAXON_REGISTRY ( AssetType  ,
AssetTypes  ,
"net.maxon.registry.assettypes"   
)

The registry for asset types.

See also
AssetType

◆ MAXON_ENUM_FLAGS() [3/34]

enum maxon::ASSET_FIND_MODE maxon::MAXON_ENUM_FLAGS ( ASSET_FIND_MODE  )

◆ MAXON_DECLARATION() [2/89]

maxon::MAXON_DECLARATION ( ComponentDescriptor  ,
AssetBaseComponent  ,
"net.maxon.component.assetbase"   
)

This base component can be used by implementations of Asset.

◆ MAXON_ENUM_LIST() [12/113]

enum maxon::REPOSITORYINDEXSTATE maxon::MAXON_ENUM_LIST ( REPOSITORYINDEXSTATE  )

◆ MAXON_REGISTRY() [4/64]

maxon::MAXON_REGISTRY ( BuiltinAssetLoaderNew  ,
BuiltinAssetLoadersNew  ,
"net.maxon.registry.builtinassetloaders2"   
)

The built-in asset repository uses this registry to find built-in assets. When its FindAssets method is invoked it forwards the call to each of the registered loaders.

◆ MAXON_REGISTRY() [5/64]

maxon::MAXON_REGISTRY ( BuiltinAssetLoader  ,
BuiltinAssetLoaders  ,
"net.maxon.registry.builtinassetloaders"   
)

◆ MAXON_REGISTRY() [6/64]

maxon::MAXON_REGISTRY ( Class< AssetRepositoryRef >  ,
AssetRepositoryTypes  ,
"net.maxon.registry.assetrepositorytypes"   
)

◆ MAXON_DECLARATION() [3/89]

maxon::MAXON_DECLARATION ( Class< AssetRepositoryRef >  ,
AssetRepositoryDecoratorBaseClass  ,
"net.maxon.class.assetrepositorydecoratorbase"   
)

A base implementation class for a decorator of AssetRepositoryRef. You can use this class as base class whenever you implement such a decorator. The class forwards calls of all methods of AssetRepositoryInterface to the decorated object.

◆ MAXON_DECLARATION() [4/89]

maxon::MAXON_DECLARATION ( Class< AssetRepositoryRef >  ,
WeakAssetRepositoryDecoratorClass  ,
"net.maxon.class.weakassetrepositorydecorator"   
)

An implementation class for a decorator of AssetRepositoryRef where the decorated repository is held by a weak reference. The class forwards calls of all methods of AssetRepositoryInterface to the decorated object.

◆ GetAssetUrl()

Url maxon::GetAssetUrl ( const DndAsset asset)

GetAssetUrl returns the url of a DndAsset.

Parameters
[in]assetDrag&Drop asset to check.
Returns
Url on success.

◆ UpdateAssetUsage()

Result<void> maxon::UpdateAssetUsage ( const AssetDescription &  asset,
Bool  incCount = true,
Bool  updateDate = true 
)

Mark the asset as used and increment the usage counter. This function will update the ASSETMETADATA::Uage meta data by increasing the count and date

Parameters
[in]assetAsset to mark.
[in]incCountTrue to update the count.
[in]updateDateTrue to update the usage count.
Returns
OK on success.

◆ IdToIdAndVersion()

Result<IdAndVersion> maxon::IdToIdAndVersion ( const Id id)

IdToIdAndVersion helper function to convert a compacted id back to an id and version.

Parameters
[in]idCompacted id.
Returns
Extracted Id and version on success.

◆ IdAndVersionToId()

Result<Id> maxon::IdAndVersionToId ( const IdAndVersion assetId)

IdAndVersionToId compacts an IdAndVersion into a id.

Parameters
[in]assetIdId to compact.
Returns
Id on success.

◆ IdToIdAndVersionWithRepository()

Result<Tuple<AssetRepositoryRef, IdAndVersion, Bool> > maxon::IdToIdAndVersionWithRepository ( const Id id,
const AssetRepositoryRef &  lookupRepository 
)

IdToIdAndVersionWithRepository calls IdToIdAndVersion and adds the repository ontop.

Parameters
[in]idId to extract.
[in]lookupRepositoryRepository to look at.
Returns
Tuple<AssetRepositoryRef, IdAndVersion, Bool> on success. Bool: limitRepository

◆ IdAndVersionToIdWithRepository()

Result<Id> maxon::IdAndVersionToIdWithRepository ( const IdAndVersion assetId,
const AssetRepositoryRef &  repository 
)

IdAndVersionToIdWithRepository inverse of IdToIdAndVersionWithRepository.

Parameters
[in]assetIdAssetId to compact.
[in]repositoryRepository to use.
Returns
OK on success.

◆ MAXON_DATATYPE() [4/73]

maxon::MAXON_DATATYPE ( StoreAssetStruct  ,
"net.maxon.datatype.storeassetstruct"   
)

◆ MAXON_DATATYPE() [5/73]

maxon::MAXON_DATATYPE ( ResolveAssetDependenciesStruct  ,
"net.maxon.datatype.resolveassetdependenciesstruct"   
)

◆ MAXON_DATATYPE() [6/73]

maxon::MAXON_DATATYPE ( AddAssetDepencendyStruct  ,
"net.maxon.datatype.addassetdepencendystruct"   
)

◆ MAXON_DECLARATION() [5/89]

maxon::MAXON_DECLARATION ( Class< BasePresetAssetType >  ,
AssetTypeBasePresetClass  ,
"net.maxon.class.assettypepresetbase"   
)

This base component can be used by implementations of BasePresetAssetTypeInterface.

◆ MAXON_DECLARATION() [6/89]

maxon::MAXON_DECLARATION ( Class< BasePresetAsset >  ,
BasePresetAssetClass  ,
"net.maxon.class.basepresetasset"   
)

This base component can be used by implementations of BasePresetAssetInterface.

◆ MAXON_ATTRIBUTE() [1/16]

maxon::MAXON_ATTRIBUTE ( void  ,
AssetCategoryUncategorized  ,
"net.maxon.assetcategory.uncategorized"   
)

Uncategorized Category. This is a default category where all assets with no category ends up.

◆ MAXON_ATTRIBUTE() [2/16]

maxon::MAXON_ATTRIBUTE ( void  ,
AssetCategoryWatchFolders  ,
"category@5846c0689c0248cfa54bffed866571ce"   
)

Special Category to collect all watch folders (S26)

◆ GetDerivedMetaData()

Result<T> maxon::GetDerivedMetaData ( const AssetDescription &  asset,
const InternedId metaId,
const CString externalStamp,
CALLBACK &&  callback 
)

Caches and returns meta data which is derived from the asset via the given callback. This helper function checks if there already exists derived meta data for the identifier #metaId with matching stamp. If so, this data is loaded if necessary and returned, otherwise {callback(asset)} is called, its result is stored (to a persistent storage) as derived meta data of the asset under @metaId and finally returned.

Both the externalStamp and the value of the meta data attribute ASSETMETADATA::DerivedMetaDataStamp are taken into account for the stamp. These two stamps are stored together with the actual data, this allows for a simple mechanism to see whether the cached data is still valid. For example if the derivation requires data from some external source, you could provide the hash code of that data as externalStamp. Then, whenever that external source changes, the cached data is considered invalid. Or, to invalidate all cached derived data of an asset, you could change the value of ASSETMETADATA::DerivedMetaDataStamp.

Derived meta data of an asset is automatically invalidated whenever persistent meta data is stored for the same asset. Also all derived meta data is invalidated when the application version changes. Therefore you don't have to take this into account for the externalStamp.

Parameters
[in]assetThe asset for which derived meta data shall be obtained.
[in]metaIdThe identifier to use for the meta data.
[in]externalStampA string to tag the cached data. Only when this matches the one used for previously cached data, that data is used, otherwise the data is newly computed by the callback.
[in]callbackA callback to derived the meta data from the asset, its meta data and external data.
Returns
The derived meta data.

◆ MAXON_DECLARATION() [7/89]

maxon::MAXON_DECLARATION ( LazyLanguageStringDataDescriptionDefinition  ,
LazyLanguageStringDataDescriptionDefinitionClass  ,
"net.maxon.class.lazylanguagestringdatadescriptiondefinition"   
)

◆ MAXON_DECLARATION() [8/89]

maxon::MAXON_DECLARATION ( LazyLanguageDictionary  ,
LazyLanguageDictionaryClass  ,
"net.maxon.class.lazylanguagedictionary"   
)

◆ MAXON_ATTRIBUTE() [3/16]

maxon::MAXON_ATTRIBUTE ( void  ,
AssetCategorySmartSearch  ,
"net.maxon.asset.category.smartsearches"   
)

◆ MAXON_DATATYPE() [7/73]

maxon::MAXON_DATATYPE ( C4DBaseDocumentType  ,
"net.maxon.datatype.c4dbasedocument"   
)

◆ MAXON_DATATYPE() [8/73]

maxon::MAXON_DATATYPE ( C4DBaseObjectType  ,
"net.maxon.datatype.c4dbaseobject"   
)

◆ MAXON_DATATYPE() [9/73]

maxon::MAXON_DATATYPE ( C4DPolyObjectType  ,
"net.maxon.datatype.c4dpolyobject"   
)

◆ MAXON_DATATYPE() [10/73]

maxon::MAXON_DATATYPE ( C4DPolyLineObjectType  ,
"net.maxon.datatype.c4dpolylineobject"   
)

◆ MAXON_DATATYPE() [11/73]

maxon::MAXON_DATATYPE ( C4DSplineObjectType  ,
"net.maxon.datatype.c4dsplineobject"   
)

◆ DT_C4DBaseDocumentType_CppName()

constexpr const maxon::Char* maxon::DT_C4DBaseDocumentType_CppName ( )
constexpr

◆ DT_C4DBaseObjectType_CppName()

constexpr const maxon::Char* maxon::DT_C4DBaseObjectType_CppName ( )
constexpr

◆ DT_C4DPolyObjectType_CppName()

constexpr const maxon::Char* maxon::DT_C4DPolyObjectType_CppName ( )
constexpr

◆ DT_C4DPolyLineObjectType_CppName()

constexpr const maxon::Char* maxon::DT_C4DPolyLineObjectType_CppName ( )
constexpr

◆ DT_C4DSplineObjectType_CppName()

constexpr const maxon::Char* maxon::DT_C4DSplineObjectType_CppName ( )
constexpr

◆ MAXON_ENUM_FLAGS() [4/34]

enum maxon::OUTPUTLOCATION maxon::MAXON_ENUM_FLAGS ( OUTPUTLOCATION  )

◆ MAXON_ENUM_LIST() [13/113]

enum maxon::ASSETINSERTOBJECTMODE maxon::MAXON_ENUM_LIST ( ASSETINSERTOBJECTMODE  )

◆ MAXON_ENUM_FLAGS() [5/34]

◆ MAXON_ENUM_FLAGS() [6/34]

enum maxon::OPENSAVEASSETDIALOGFLAGS maxon::MAXON_ENUM_FLAGS ( OPENSAVEASSETDIALOGFLAGS  )

◆ MAXON_ENUM_FLAGS() [7/34]

enum maxon::ASSETPOPUPOPTIONS maxon::MAXON_ENUM_FLAGS ( ASSETPOPUPOPTIONS  )

◆ MAXON_ENUM_LIST() [14/113]

enum maxon::VIEW_MODE maxon::MAXON_ENUM_LIST ( VIEW_MODE  )

◆ GetActiveCE()

Result<CodeExchangerRef> maxon::GetActiveCE ( )

Retrieves the Code Exchanger that should be used. @detail By default the WebSocket Json Code Exchanger is used but the user can define which one to use in the Code Exchanger Settings located within the Script Manager menu.

Returns
The Code Exchanger that the user decided to to use.

◆ StoreActiveCE()

Result<void> maxon::StoreActiveCE ( CodeExchangerRef  ce)

Defines the Code Exchanger that should be used.

Parameters
[in]ceThe Code Exchanger that should be used.

◆ MAXON_REGISTRY() [7/64]

maxon::MAXON_REGISTRY ( Class< CodeExchangerRef >  ,
CodeExchangers  ,
"net.maxon.registry.codeexchanger"   
)

◆ MAXON_DATATYPE() [12/73]

maxon::MAXON_DATATYPE ( CommandGetStateDelegate  ,
"net.maxon.hybrid.datatype.commandgetstate"   
)

◆ MAXON_REGISTRY() [8/64]

maxon::MAXON_REGISTRY ( CommandGetStateDelegate  ,
CommandGetStateDelegates  ,
"net.maxon.hybrid.command.getstates"   
)

◆ MAXON_DATATYPE() [13/73]

maxon::MAXON_DATATYPE ( CreateMaterialWithDataDelegate  ,
"net.maxon.hybrid.datatype.creatematerialwithdatadelegate"   
)

◆ MAXON_REGISTRY() [9/64]

maxon::MAXON_REGISTRY ( CreateMaterialWithDataDelegate  ,
CreateMaterialWithDataDelegates  ,
"net.maxon.hybrid.command.creatematerialwithdata"   
)

◆ MAXON_DATATYPE() [14/73]

maxon::MAXON_DATATYPE ( CreateDefaultMaterialDelegate  ,
"net.maxon.hybrid.datatype.createdefaultmaterialdelegate"   
)

◆ MAXON_REGISTRY() [10/64]

maxon::MAXON_REGISTRY ( CreateDefaultMaterialDelegate  ,
CreateDefaultMaterialDelegates  ,
"net.maxon.hybrid.command.createdefaultmaterials"   
)

◆ GetPyElemFromNode()

Result<PythonElementBaseRef> maxon::GetPyElemFromNode ( FactoryInterface::ConstPtr  factory,
BaseList2D bl 
)

◆ MAXON_DECLARATION() [9/89]

maxon::MAXON_DECLARATION ( Class< PythonElementBaseRef >  ,
PythonElementBaseClass  ,
"net.maxon.class.python_element.base"   
)

◆ MAXON_DECLARATION() [10/89]

maxon::MAXON_DECLARATION ( PyBaseElementFactoryType  ,
PyBaseElementFactory  ,
"net.maxon.factory.python_element.base"   
)

◆ MAXON_DECLARATION() [11/89]

maxon::MAXON_DECLARATION ( Class< PythonElementEmbeddedRef >  ,
PythonEmbeddedClass  ,
"net.maxon.class.python_element.embedded"   
)

◆ MAXON_DECLARATION() [12/89]

maxon::MAXON_DECLARATION ( PyEmbeddedElementFactoryType  ,
PyEmbeddedElementFactory  ,
"net.maxon.factory.python_element.embedded"   
)

◆ MAXON_DECLARATION() [13/89]

maxon::MAXON_DECLARATION ( Class< PythonElementBaseRef >  ,
PythonDirectoryClass  ,
"net.maxon.class.python_element.directory"   
)

◆ MAXON_DECLARATION() [14/89]

maxon::MAXON_DECLARATION ( PyDirectoryElementFactoryType  ,
PyDirectoryElementFactory  ,
"net.maxon.factory.python_element.directory"   
)

◆ MAXON_DECLARATION() [15/89]

maxon::MAXON_DECLARATION ( Class< PythonElementScriptRef >  ,
PythonScriptClass  ,
"net.maxon.class.python_element.script"   
)

◆ MAXON_DECLARATION() [16/89]

maxon::MAXON_DECLARATION ( PyScriptElementFactoryType  ,
PyScriptElementFactory  ,
"net.maxon.factory.python_element.script"   
)

◆ MAXON_REGISTRY() [11/64]

maxon::MAXON_REGISTRY ( Class< PythonBaseList2DDetectorRef >  ,
PyBaseList2DDetectors  ,
"net.maxon.registry.python_baselist2d_detector"   
)

◆ MAXON_DECLARATION() [17/89]

maxon::MAXON_DECLARATION ( Class< PyElementManagerRef >  ,
PyElementManager  ,
"net.maxon.py_element_manager_interface"   
)

◆ MAXON_REGISTRY() [12/64]

maxon::MAXON_REGISTRY ( UiConversion  ,
UiConversions  ,
"net.maxon.image.registry.uiconversions"   
)

◆ MAXON_DECLARATION() [18/89]

maxon::MAXON_DECLARATION ( maxon::Class< WebSocketJsonCodeExchangerRef >  ,
WebSocketJsonCodeExchanger  ,
"net.maxonsdk.class.codeexchanger.websocket_json"   
)

◆ MAXON_ENUM_LIST() [15/113]

enum maxon::COMMANDSTATE maxon::MAXON_ENUM_LIST ( COMMANDSTATE  )

◆ MAXON_ENUM_LIST() [16/113]

enum maxon::COMMANDRESULT maxon::MAXON_ENUM_LIST ( COMMANDRESULT  )

◆ MAXON_ENUM_LIST() [17/113]

enum maxon::INTERACTIONTYPE maxon::MAXON_ENUM_LIST ( INTERACTIONTYPE  ,
"net.maxon.command.interationtype"   
)

◆ Param()

static Tuple<InternedId, Data> maxon::Param ( KEY &&  key,
T &&  data 
)
static

PARAM allows to invoke a command and to set the command data at the same time. Example usage: maxon::CommandDataRef commandData = maxon::CommandDataClasses::BASE().Create() iferr_return; maxon::COMMANDRESULT result = commandData.Invoke(maxon::CommandClasses::PAINT(), true, Param(maxon::COMMAND::POLYLINE::DRAW, maxon::POLYLINE_DRAW::BOX), Param(maxon::COMMAND::POLYLINE::START, Vector(mouseX, mouseY, 0.0)), Param(maxon::COMMAND::POLYLINE::END, Vector(mouseX, mouseY, 0.0))) iferr_return;

◆ MAXON_ENUM_LIST() [18/113]

enum MAXON_WARN_UNUSED_CLASS maxon::COMMAND_ACTION_STATE maxon::MAXON_ENUM_LIST ( COMMAND_ACTION_STATE  )

◆ MAXON_DATATYPE() [15/73]

maxon::MAXON_DATATYPE ( CommandCacheData  ,
"net.maxon.datatype.commandcachedata"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.command")   
)

◆ MAXON_DATATYPE() [16/73]

maxon::MAXON_DATATYPE ( CommandCacheMap  ,
"net.maxon.datatype.commandcachemap"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.command")   
)

◆ MAXON_REGISTRY() [13/64]

maxon::MAXON_REGISTRY ( Class< CommandDataRef >  ,
CommandDataClasses  ,
"net.maxon.command.registry.commanddataclasses"   
)

◆ MAXON_REGISTRY() [14/64]

maxon::MAXON_REGISTRY ( Class< LegacyCommandDataRef >  ,
LegacyCommandDataClasses  ,
"net.maxon.command.registry.legacycommanddataclasses"   
)

◆ MAXON_REGISTRY() [15/64]

maxon::MAXON_REGISTRY ( CommandClass  ,
CommandClasses  ,
"net.maxon.command.registry.commandclasses"   
)

◆ MAXON_REGISTRY() [16/64]

maxon::MAXON_REGISTRY ( LegacyCommandClass  ,
LegacyCommand  ,
"net.maxon.command.registry.legacycommandclass"   
)

◆ MAXON_REGISTRY() [17/64]

maxon::MAXON_REGISTRY ( MigratedCommandClass  ,
MigratedCommand  ,
"net.maxon.command.registry.migratedcommandclass"   
)

◆ MAXON_REGISTRY() [18/64]

maxon::MAXON_REGISTRY ( CommandInteractionClass  ,
CommandInteraction  ,
"net.maxon.command.registry.commandinteractionclass"   
)

◆ MAXON_REGISTRY() [19/64]

maxon::MAXON_REGISTRY ( CommandDescriptionClass  ,
CommandDescription  ,
"net.maxon.command.registry.commanddescriptionclass"   
)

◆ MAXON_REGISTRY() [20/64]

maxon::MAXON_REGISTRY ( CommandConversionClass  ,
CommandConversionClasses  ,
"net.maxon.command.registry.commandconversionclasses"   
)

◆ MAXON_REGISTRY() [21/64]

maxon::MAXON_REGISTRY ( Class< CommandCacheRef >  ,
CommandCacheClasses  ,
"net.maxon.command.registry.commandcacheclasses"   
)

◆ MAXON_DECLARATION() [19/89]

maxon::MAXON_DECLARATION ( Class< CommandObserverRef >  ,
CommandObserverObjectClass  ,
"net.maxon.command.class.observer"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.command")   
)

◆ MAXON_DATATYPE() [17/73]

maxon::MAXON_DATATYPE ( InvocationState  ,
"net.maxon.datatype.command.invokationstate"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.command")   
)

◆ MAXON_REGISTRY() [22/64]

maxon::MAXON_REGISTRY ( NO_VALUE_TYPE  ,
MemoizationTypes  ,
"net.maxon.registry.memoization"   
)

◆ TestForBeginFunction()

std::false_type maxon::TestForBeginFunction ( OverloadRank0  )

◆ TestForEndFunction()

std::false_type maxon::TestForEndFunction ( OverloadRank0  )

◆ ConstructElements() [1/2]

auto maxon::ConstructElements ( ITERATOR  first,
SENTINEL  sentinel,
const ARGS &...  args 
) -> ITERATOR

Initializes elements of value_type type in a sequence by calling their constructor with given arguments. Cannot fail.

Parameters
[in]firstStart of uninitialized sequence, i.e. pointer to first element.
[in]sentinelSequence delimiter, i.e. pointer to one position after the last element.
[in]argsConstructor arguments.
Returns
Iterator to end of the constructed sequence.

◆ ConstructElements() [2/2]

auto maxon::ConstructElements ( ITERABLE &&  iterable,
const ARGS &...  args 
) -> decltype(begin(iterable))

Equivalent to ConstructElements(begin(iterable), end(iterable), args ...).

◆ DestructElements() [1/2]

auto maxon::DestructElements ( ITERATOR  first,
SENTINEL  sentinel 
) -> ITERATOR

Destructs elements of value_type in a sequence. Cannot fail.

Parameters
[in]firstStart of sequence, i.e. pointer to first element.
[in]sentinelSequence delimiter, i.e. pointer to one position after the last element.
Returns
Iterator to end of the destructed sequence.

◆ DestructElements() [2/2]

auto maxon::DestructElements ( ITERABLE &&  iterable) -> decltype(begin(iterable))

Equivalent to Destruct(begin(iterable), end(iterable)).

◆ Copy() [1/2]

auto maxon::Copy ( ITERATOR  first,
SENTINEL  sentinel,
DEST_ITERATOR  dest 
) -> Result<DEST_ITERATOR>

Copy-assigns elements of value_type from one sequence to another. The destination sequence is expected to contain initialized values.

This function behaves similar to std::copy, but uses maxon error handling instead of exceptions. If copying an object cannot fail, i.e. for POD-types, copy assignment is used. If copying an object can fail, i.e. because of allocations, a member function Result<void> CopyFrom(const T&) must be implemented; copying an object then happens through CopyFrom().

Parameters
[in]firstStart of source sequence, i.e. pointer to first element.
[in]sentinelSource sequence delimiter, i.e. pointer to one position after the last element.
[in]destStart of destination sequence, i.e. pointer to first element.
Returns
End of the resulting destination sequence, or error if CopyFrom() failed.

◆ Copy() [2/2]

auto maxon::Copy ( const ITERABLE &  iterable,
DEST_ITERATOR  dest 
) -> Result<DEST_ITERATOR>

Equivalent to Copy(begin(iterable), end(iterable), dest).

◆ CopyIf() [1/2]

auto maxon::CopyIf ( ITERATOR  first,
SENTINEL  sentinel,
DEST_ITERATOR  dest,
PREDICATE  pred 
) -> Result<DEST_ITERATOR>

Equivalent to Copy, but only copies elements that match the given predicate. The predicate function should have a signature equivalent to

Bool func(const ElementType&);
PyObject Py_tracefunc func
Definition: ceval.h:10
Parameters
[in]firstStart of source sequence, i.e. pointer to first element.
[in]sentinelSource sequence delimiter, i.e. pointer to one position after the last element.
[in]destStart of destination sequence, i.e. pointer to first element.
[in]predA unary predicate.
Returns
End of the resulting destination sequence, or error if CopyFrom() failed.

◆ CopyIf() [2/2]

auto maxon::CopyIf ( const ITERABLE &  iterable,
DEST_ITERATOR  dest,
PREDICATE  pred 
) -> Result<DEST_ITERATOR>

Equivalent to CopyIf(begin(iterable), end(iterable), dest, pred).

◆ CopyToUninitialized() [1/2]

auto maxon::CopyToUninitialized ( ITERATOR  first,
SENTINEL  sentinel,
DEST_ITERATOR  dest 
) -> Result<DEST_ITERATOR>

Copy-constructs elements of value_type from one sequence to another. The destination sequence is expected to contain uninitialized values.

See Copy for more details.

Parameters
[in]firstStart of source sequence, i.e. pointer to first element.
[in]sentinelSource sequence delimiter, i.e. pointer to one position after the last element.
[in]destStart of destination sequence, i.e. pointer to first element.
Returns
End of the resulting destination sequence, or error if CopyFrom() failed.

◆ CopyToUninitialized() [2/2]

auto maxon::CopyToUninitialized ( const ITERABLE &  iterable,
DEST_ITERATOR  dest 
) -> Result<DEST_ITERATOR>

Equivalent to CopyToUninitialized(begin(iterable), end(iterable), dest).

◆ CopyToUninitializedIf() [1/2]

auto maxon::CopyToUninitializedIf ( ITERATOR  first,
SENTINEL  sentinel,
DEST_ITERATOR  dest,
PREDICATE  pred 
) -> Result<DEST_ITERATOR>

Equivalent to CopyToUninitialized, but only copies elements that match the given predicate. The predicate function should have a signature equivalent to

Bool func(const ElementType&);
Parameters
[in]firstStart of source sequence, i.e. pointer to first element.
[in]sentinelSource sequence delimiter, i.e. pointer to one position after the last element.
[in]destStart of destination sequence, i.e. pointer to first element.
[in]predA unary predicate.
Returns
End of the resulting destination sequence, or error if CopyFrom() failed.

◆ CopyToUninitializedIf() [2/2]

auto maxon::CopyToUninitializedIf ( const ITERABLE &  iterable,
DEST_ITERATOR  dest,
PREDICATE  pred 
) -> Result<DEST_ITERATOR>

Equivalent to CopyToUninitializedIf(begin(iterable), end(iterable), dest, pred).

◆ MAXON_ENUM_LIST() [19/113]

enum maxon::MOVE_MODE maxon::MAXON_ENUM_LIST ( MOVE_MODE  )

◆ Move() [1/2]

auto maxon::Move ( ITERATOR  first,
SENTINEL  sentinel,
DEST_ITERATOR  dest 
) -> DEST_ITERATOR

Move-assigns elements of value_type from one sequence to another. The destination sequence is expected to contain initialized values. The MODE parameter controls whether the elements in the source sequence will be destructed. Cannot fail.

This function behaves similar to std::move(a, b) (from <algorithm> - not to be mistaken for the one from <utility>).

Template Parameters
MODEFlags to control the behavior of this function.
Parameters
[in]firstStart of source sequence, i.e. pointer to first element.
[in]sentinelSource sequence delimiter, i.e. pointer to one position after the last element.
[in]destStart of destination sequence, i.e. pointer to first element.
Returns
End of the resulting destination sequence.

◆ Move() [2/2]

auto maxon::Move ( ITERABLE &&  iterable,
DEST_ITERATOR  dest 
) -> DEST_ITERATOR

Equivalent to Move(begin(iterable), end(iterable), dest).

◆ MoveIf() [1/2]

auto maxon::MoveIf ( ITERATOR  first,
SENTINEL  sentinel,
DEST_ITERATOR  dest,
PREDICATE  pred 
) -> DEST_ITERATOR

Equivalent to Move, but only copies elements that match the given predicate. The predicate function should have a signature equivalent to

Bool func(const ElementType&);
Parameters
[in]firstStart of source sequence, i.e. pointer to first element.
[in]sentinelSource sequence delimiter, i.e. pointer to one position after the last element.
[in]destStart of destination sequence, i.e. pointer to first element.
[in]predA unary predicate.
Returns
End of the resulting destination sequence.

◆ MoveIf() [2/2]

auto maxon::MoveIf ( ITERABLE &&  iterable,
DEST_ITERATOR  dest,
PREDICATE  pred 
) -> DEST_ITERATOR

Equivalent to MoveIf(begin(iterable), end(iterable), dest, pred).

◆ MoveToUninitialized() [1/2]

auto maxon::MoveToUninitialized ( ITERATOR  first,
SENTINEL  sentinel,
DEST_ITERATOR  dest 
) -> DEST_ITERATOR

Move-constructs elements of value_type from one sequence to another. The destination sequence is expected to contain uninitialized values. The MODE parameter controls whether the elements in the source sequence will be destructed. Cannot fail.

This function behaves similar to std::move(a, b) (from <algorithm> - not to be mistaken for the one from <utility>).

Template Parameters
MODEFlags to control the behavior of this function.
Parameters
[in]firstStart of source sequence, i.e. pointer to first element.
[in]sentinelSource sequence delimiter, i.e. pointer to one position after the last element.
[in]destStart of destination sequence, i.e. pointer to first element.
Returns
End of the resulting destination sequence.

◆ MoveToUninitialized() [2/2]

auto maxon::MoveToUninitialized ( ITERABLE &&  iterable,
DEST_ITERATOR  dest 
) -> DEST_ITERATOR

Equivalent to MoveToUninitialized(begin(iterable), end(iterable), dest).

◆ MoveToUninitializedIf() [1/2]

auto maxon::MoveToUninitializedIf ( ITERATOR  first,
SENTINEL  sentinel,
DEST_ITERATOR  dest,
PREDICATE  pred 
) -> DEST_ITERATOR

Equivalent to MoveToUninitializedIf, but only moves elements that match the given predicate. The predicate function should have a signature equivalent to

Bool func(const ElementType&);
Parameters
[in]firstStart of source sequence, i.e. pointer to first element.
[in]sentinelSource sequence delimiter, i.e. pointer to one position after the last element.
[in]destStart of destination sequence, i.e. pointer to first element.
[in]predA unary predicate.
Returns
End of the resulting destination sequence.

◆ MoveToUninitializedIf() [2/2]

auto maxon::MoveToUninitializedIf ( ITERABLE &&  iterable,
DEST_ITERATOR  dest,
PREDICATE  pred 
) -> DEST_ITERATOR

Equivalent to MoveToUninitializedIf(begin(iterable), end(iterable), dest, pred).

◆ Fill() [1/2]

auto maxon::Fill ( ITERABLE &&  iterable,
const T &  value 
) -> decltype(begin(iterable))

Equivalent to Fill(begin(iterable), end(iterable), value).

◆ Generate() [1/2]

auto maxon::Generate ( ITERATOR  first,
SENTINEL  sentinel,
GENERATOR  gen 
) -> ITERATOR

Assigns the given value to all elements in a sequence. The sequence is expected to contain initialized data. The generator function should have a signature equivalent to

ElementType func();

This function is the equivalent to std::generate.

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]genGenerator function.
Returns
End of generated sequence.

◆ Generate() [2/2]

auto maxon::Generate ( ITERABLE &&  iterable,
GENERATOR  gen 
) -> decltype(begin(iterable))

Equivalent to Generate(begin(iterable), end(iterable), gen).

◆ AllOf() [1/2]

Bool maxon::AllOf ( ITERATOR  first,
SENTINEL  sentinel,
PREDICATE  pred 
)

Returns whether the given unary predicate is true for all elements in a sequence. The predicate function should have a signature equivalent to

Bool func(const ElementType&);

This function is the equivalent to std::all_of.

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]predUnary predicate function.
Returns
True if predicate was true for all elements.

◆ AllOf() [2/2]

Bool maxon::AllOf ( const ITERABLE &  iterable,
PREDICATE  pred 
)

Equivalent to AllOf(begin(iterable), end(iterable), pred).

◆ AnyOf() [1/2]

Bool maxon::AnyOf ( ITERATOR  first,
SENTINEL  sentinel,
PREDICATE  pred 
)

Returns whether the given unary predicate is true for all elements in a sequence. The predicate function should have a signature equivalent to

Bool func(const ElementType&);

This function is the equivalent to std::any_of.

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]predUnary predicate function.
Returns
True if predicate was true for any element.

◆ AnyOf() [2/2]

Bool maxon::AnyOf ( const ITERABLE &  iterable,
PREDICATE  pred 
)

Equivalent to AnyOf(begin(iterable), end(iterable), pred).

◆ NoneOf() [1/2]

Bool maxon::NoneOf ( ITERATOR  first,
SENTINEL  sentinel,
PREDICATE  pred 
)

Returns whether the given unary predicate is true none of the elements in a sequence. The predicate function should have a signature equivalent to

Bool func(const ElementType&);

This function is the equivalent to std::none_of.

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]predUnary predicate function.
Returns
True if predicate was true none of the elements.

◆ NoneOf() [2/2]

Bool maxon::NoneOf ( const ITERABLE &  iterable,
PREDICATE  pred 
)

Equivalent to NoneOf(begin(iterable), end(iterable), pred).

◆ Equal() [1/4]

Bool maxon::Equal ( ITERATOR1  first1,
SENTINEL1  sentinel1,
ITERATOR2  first2,
SENTINEL2  sentinel2 
)

Returns whether the elements of two sequences are pair-wise equal, i.e. when they have the same length and seq1[i] == se2[i] for all i.

This function is the equivalent to std::equal.

Parameters
[in]first1Start of first sequence.
[in]sentinel1First sequence delimiter.
[in]first2Start of second sequence.
[in]sentinel2Second sequence delimiter.
Returns
True if both sequences are equal.

◆ Equal() [2/4]

Bool maxon::Equal ( const ITERABLE1 &  iterable1,
const ITERABLE2 &  iterable2 
)

Equivalent to Equal(begin(iterable1), end(iterable1), begin(iterable2), end(iterable2)).

◆ Equal() [3/4]

Bool maxon::Equal ( ITERATOR1  first1,
SENTINEL1  sentinel1,
ITERATOR2  first2,
SENTINEL2  sentinel2,
COMPARE  comp 
)

Equivalent to Equal, but uses a custom compare function instead of equality. The compare function should have a signature equivalent to

Bool comp(const ElementType1&, const ElementType2&);
Parameters
[in]first1Start of first sequence.
[in]sentinel1First sequence delimiter.
[in]first2Start of second sequence.
[in]sentinel2Second sequence delimiter.
[in]compBinary compare function.
Returns
True if both sequences are equal.

◆ Equal() [4/4]

Bool maxon::Equal ( const ITERABLE1 &  iterable1,
const ITERABLE2 &  iterable2,
COMPARE  comp 
)

Equivalent to Equal(begin(iterable1), end(iterable1), begin(iterable2), end(iterable2), comp).

◆ Mismatch() [1/4]

auto maxon::Mismatch ( ITERATOR1  first1,
SENTINEL1  sentinel1,
ITERATOR2  first2,
SENTINEL2  sentinel2 
) -> Optional<Pair<ITERATOR1, ITERATOR2>>

Returns whether there's a pair-wise mismatch between elements of two sequences. If no mismatch was found, i.e. both sequences are equal (

See also
Equal), NO_VALUE is returned. If a mismatch was found and both sequences have the same length, a pair of iterators to the mismatching elements is returned. If length(seq1) < length(seq2), a pair (end(seq1), it2) is returned, and vice versa.

This function is the equivalent to std::mismatch.

Parameters
[in]first1Start of first sequence.
[in]sentinel1First sequence delimiter.
[in]first2Start of second sequence.
[in]sentinel2Second sequence delimiter.
Returns
Optional pair of mismatched elements.

◆ Mismatch() [2/4]

auto maxon::Mismatch ( ITERABLE1 &&  iterable1,
ITERABLE2 &&  iterable2 
) -> Optional<Pair<decltype(begin(iterable1)), decltype(begin(iterable2))>>

Equivalent to Mismatch(begin(iterable1), end(iterable1), begin(iterable2), end(iterable2)).

◆ Mismatch() [3/4]

auto maxon::Mismatch ( ITERATOR1  first1,
SENTINEL1  sentinel1,
ITERATOR2  first2,
SENTINEL2  sentinel2,
COMPARE  comp 
) -> Optional<Pair<ITERATOR1, ITERATOR2>>

Equivalent to Mismatch, but uses a custom compare function instead of equality. The compare function should have a signature equivalent to

Bool comp(const ElementType1&, const ElementType2&);
Parameters
[in]first1Start of first sequence.
[in]sentinel1First sequence delimiter.
[in]first2Start of second sequence.
[in]sentinel2Second sequence delimiter.
[in]compBinary compare function.
Returns
Optional pair of mismatched elements.

◆ Mismatch() [4/4]

auto maxon::Mismatch ( ITERABLE1 &&  iterable1,
ITERABLE2 &&  iterable2,
COMPARE  comp 
) -> Optional<Pair<decltype(begin(iterable1)), decltype(begin(iterable2))>>

Equivalent to Mismatch(begin(iterable1), end(iterable1), begin(iterable2), end(iterable2), comp).

◆ Partition() [1/3]

auto maxon::Partition ( ITERATOR  first,
ITERATOR  last,
PREDICATE  pred 
) -> ITERATOR

Reorders elements in sequence [first, last) so that the given unary predicate is true for all elements [first, p) and false for all elements in [p, last), i.e. all elements that match the predicate are placed in front of those that don't. The ordering of the elements is not preserved (

See also
StablePartition). The predicate function should have a signature equivalent to
Bool func(const ElementType&);

This function is the equivalent to std::partition.

Parameters
[in]firstStart of sequence.
[in]lastEnd of sequence.
[in]predUnary predicate function.
Returns
Iterator of partition point p.

◆ Partition() [2/3]

auto maxon::Partition ( ITERATOR  first,
SENTINEL  sentinel,
PREDICATE  pred 
) -> ITERATOR

Equivalent to Partition(first, last, pred). last is determined by incrementing first until it matches the sequence delimiter sentinel.

◆ Partition() [3/3]

auto maxon::Partition ( ITERABLE &&  iterable,
PREDICATE  pred 
) -> decltype(begin(iterable))

Equivalent to Partition(begin(iterable), end(iterable), pred).

◆ IsPartitioned() [1/3]

Bool maxon::IsPartitioned ( ITERATOR  first,
ITERATOR  last,
PREDICATE  pred 
)

Returns whether a sequence is partitioned by the given predicate, i.e. there's a partition point p so that the predicate is true for all [first, p) and false for all [p, last). The predicate function should have a signature equivalent to

Bool func(const ElementType&);

This function is the equivalent to std::is_partitioned.

Parameters
[in]firstStart of sequence.
[in]lastEnd of sequence.
[in]predUnary predicate function.
Returns
True if sequence is partitioned.

◆ IsPartitioned() [2/3]

Bool maxon::IsPartitioned ( ITERATOR  first,
SENTINEL  sentinel,
PREDICATE  pred 
)

Equivalent to IsPartitioned(first, last, pred). last is determined by incrementing first until it matches the sequence delimiter sentinel.

◆ IsPartitioned() [3/3]

Bool maxon::IsPartitioned ( const ITERABLE &  iterable,
PREDICATE  pred 
)

Equivalent to IsPartitioned(begin(iterable), end(iterable), pred).

◆ Reverse() [1/5]

auto maxon::Reverse ( ITERABLE &&  iterable) -> decltype(begin(iterable))

Equivalent to Reverse(begin(iterable), end(iterable)).

◆ LowerBound() [1/6]

auto maxon::LowerBound ( ITERATOR  first,
ITERATOR  last,
const T &  value 
) -> ITERATOR

Returns an iterator to the first element in a sequence that is equal or greater than the given value. If such an element does not exist, the end of the sequence is returned. Binary search is used to locate the element, so the sequence must be ordered. Elements must be comparable with the less-than operator.

This function is the equivalent to std::lower_bound.

Parameters
[in]firstStart of sequence.
[in]lastEnd of sequence.
[in]valueThe bounding value.
Returns
Iterator to position of the lower bound.

◆ LowerBound() [2/6]

auto maxon::LowerBound ( ITERATOR  first,
ITERATOR  last,
const T &  value,
COMPARE  comp 
) -> ITERATOR

Equivalent to LowerBound, but uses the given function to compare elements instead of the less-than operator. The sequence must be ordered by the same function. The compare function should have a signature equivalent to

Bool comp(const ElementType1&, const ElementType2&);
Parameters
[in]firstStart of sequence.
[in]lastEnd of sequence.
[in]valueThe bounding value.
[in]compBinary compare function.
Returns
Iterator to position of the lower bound.

◆ LowerBound() [3/6]

auto maxon::LowerBound ( ITERATOR  first,
SENTINEL  sentinel,
const T &  value 
) -> ITERATOR

Equivalent to LowerBound(first, last, value). last is determined by incrementing first until it matches the sequence delimiter sentinel.

◆ LowerBound() [4/6]

auto maxon::LowerBound ( ITERATOR  first,
SENTINEL  sentinel,
const T &  value,
COMPARE  comp 
) -> ITERATOR

Equivalent to LowerBound(first, last, value, comp). last is determined by incrementing first until it matches the sequence delimiter sentinel.

◆ LowerBound() [5/6]

auto maxon::LowerBound ( ITERABLE &&  iterable,
const T &  value 
) -> decltype(begin(iterable))

Equivalent to LowerBound(begin(iterable), end(iterable), value).

◆ LowerBound() [6/6]

auto maxon::LowerBound ( ITERABLE &&  iterable,
const T &  value,
COMPARE  comp 
) -> decltype(begin(iterable))

Equivalent to LowerBound(begin(iterable), end(iterable), value, comp).

◆ UpperBound() [1/6]

auto maxon::UpperBound ( ITERATOR  first,
ITERATOR  last,
const T &  value 
) -> ITERATOR

Returns an iterator to the first element in a sequence that is greater than the given value. If such an element does not exist, the end of the sequence is returned. Binary search is used to locate the element, so the sequence must be ordered. Elements must be comparable with the less-than operator.

This function is the equivalent to std::upper_bound.

Parameters
[in]firstStart of sequence.
[in]lastEnd of sequence.
[in]valueThe bounding value.
Returns
Iterator to position of the upper bound.

◆ UpperBound() [2/6]

auto maxon::UpperBound ( ITERATOR  first,
ITERATOR  last,
const T &  value,
COMPARE  comp 
) -> ITERATOR

Equivalent to UpperBound, but uses the given function to compare elements instead of the less-than operator. The sequence must be ordered by the same function. The compare function should have a signature equivalent to

Bool comp(const ElementType1&, const ElementType2&);
Parameters
[in]firstStart of sequence.
[in]lastEnd of sequence.
[in]valueThe bounding value.
[in]compBinary compare function.
Returns
Iterator to position of the upper bound.

◆ UpperBound() [3/6]

auto maxon::UpperBound ( ITERATOR  first,
SENTINEL  sentinel,
const T &  value 
) -> ITERATOR

Equivalent to UpperBound(first, last, value). last is determined by incrementing first until it matches the sequence delimiter sentinel.

◆ UpperBound() [4/6]

auto maxon::UpperBound ( ITERATOR  first,
SENTINEL  sentinel,
const T &  value,
COMPARE  comp 
) -> ITERATOR

Equivalent to UpperBound(first, last, value, comp). last is determined by incrementing first until it matches the sequence delimiter sentinel.

◆ UpperBound() [5/6]

auto maxon::UpperBound ( ITERABLE &&  iterable,
const T &  value 
) -> decltype(begin(iterable))

Equivalent to LowerBound(begin(iterable), end(iterable), value).

◆ UpperBound() [6/6]

auto maxon::UpperBound ( ITERABLE &&  iterable,
const T &  value,
COMPARE  comp 
) -> decltype(begin(iterable))

Equivalent to LowerBound(begin(iterable), end(iterable), value, comp).

◆ BinarySearch() [1/6]

auto maxon::BinarySearch ( ITERATOR  first,
ITERATOR  last,
const T &  value 
) -> Optional<ITERATOR>

Returns an iterator to the first element in a sequence that is equal to the given value, or NO_VALUE if no match was found. Binary search is used to locate the element, so the sequence must be ordered. Elements must be comparable with the less-than operator.

Parameters
[in]firstStart of sequence.
[in]lastEnd of sequence.
[in]valueThe bounding value.
Returns
Iterator to position of the found element.

◆ BinarySearch() [2/6]

auto maxon::BinarySearch ( ITERATOR  first,
SENTINEL  sentinel,
const T &  value 
) -> Optional<ITERATOR>

Equivalent to BinarySearch(first, last, value). last is determined by incrementing first until it matches the sequence delimiter sentinel.

◆ BinarySearch() [3/6]

auto maxon::BinarySearch ( ITERATOR  first,
ITERATOR  last,
const T &  value,
COMPARE  comp 
) -> Optional<ITERATOR>

Equivalent to BinarySearch, but uses the given function to compare elements instead of the less-than operator. The sequence must be ordered by the same function. The compare function should have a signature equivalent to

Bool comp(const ElementType1&, const ElementType2&);
Parameters
[in]firstStart of sequence.
[in]lastEnd of sequence.
[in]valueThe bounding value.
[in]compBinary compare function.
Returns
Iterator to position of the upper bound.

◆ BinarySearch() [4/6]

auto maxon::BinarySearch ( ITERATOR  first,
SENTINEL  sentinel,
const T &  value,
COMPARE  comp 
) -> Optional<ITERATOR>

Equivalent to BinarySearch(first, last, value, comp). last is determined by incrementing first until it matches the sequence delimiter sentinel.

◆ BinarySearch() [5/6]

auto maxon::BinarySearch ( ITERABLE &&  iterable,
const T &  value 
) -> decltype(begin(iterable))

Equivalent to BinarySearch(begin(iterable), end(iterable), value).

◆ BinarySearch() [6/6]

auto maxon::BinarySearch ( ITERABLE &&  iterable,
const T &  value,
COMPARE  comp 
) -> decltype(begin(iterable))

Equivalent to BinarySearch(begin(iterable), end(iterable), value, comp).

◆ Rotate() [1/3]

auto maxon::Rotate ( ITERATOR  first,
ITERATOR  last,
ITERATOR  newFirst 
) -> ITERATOR

Rotates elements in sequence [first, last) to the left so that newFirst becomes the new first element.

Example:

CArray<Int> values = { 1, 2, 3, 4, 5, 6 };
auto match = BinarySearch(values, 3);
if (match)
auto it = Rotate(begin(values), end(values), match.GetPosition());
// New order: { 3, 4, 5, 6, 1, 2 }
// it points to position at index 4 (value 1).
MAXON_ATTRIBUTE_FORCE_INLINE auto end(COLLECTION &&c) -> decltype(c.End())
Definition: foreach.h:361
MAXON_ATTRIBUTE_FORCE_INLINE auto begin(COLLECTION &&c) -> decltype(c.Begin())
Definition: foreach.h:356
auto Rotate(ITERATOR first, ITERATOR last, ITERATOR newFirst) -> ITERATOR
Definition: algorithms.h:1385
auto BinarySearch(ITERATOR first, ITERATOR last, const T &value) -> Optional< ITERATOR >
Definition: algorithms.h:1281

This function is the equivalent to std::rotate. Note that the order of the arguments is different here.

Parameters
[in]firstStart of sequence.
[in]lastEnd of sequence.
[in]newFirstIterator to element that should become the new first element.
Returns
Iterator to new position of old first element.

◆ Rotate() [2/3]

auto maxon::Rotate ( ITERABLE &&  iterable,
ITERATOR  newFirst 
) -> ITERATOR

Equivalent to Rotate(begin(iterable), end(iterable), newFirst).

◆ Rotate() [3/3]

auto maxon::Rotate ( ITERATOR  first,
SENTINEL  sentinel,
ITERATOR  newFirst 
) -> ITERATOR

Equivalent to Rotate(first, last, newFirst). last is determined by incrementing first until it matches the sequence delimiter sentinel.

◆ Count() [1/2]

Int maxon::Count ( ITERATOR  first,
SENTINEL  sentinel,
const T &  value 
)

Returns the number of elements in a sequence that are equal to the given value.

This function is the equivalent to std::count.

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]valueThe counted value.
Returns
Number of occurrences.

◆ Count() [2/2]

Int maxon::Count ( ITERABLE &&  iterable,
const T &  value 
)

Equivalent to Count(begin(iterable), end(iterable), value).

◆ CountIf() [1/2]

Int maxon::CountIf ( ITERATOR  first,
SENTINEL  sentinel,
PREDICATE  pred 
)

Returns the number of elements in a sequence that are matched by the given predicate. The predicate function should have a signature equivalent to

Bool func(const ElementType&);

This function is the equivalent to std::count_if.

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]predUnary predicate.
Returns
Number of occurrences.

◆ CountIf() [2/2]

auto maxon::CountIf ( const ITERABLE &  iterable,
PREDICATE  pred 
) -> Int

Equivalent to CountIf(begin(iterable), end(iterable), pred).

◆ Unique() [1/4]

auto maxon::Unique ( ITERATOR  first,
SENTINEL  sentinel 
) -> ITERATOR

Re-arranges elements in sequence so that consecutive (!) duplicate elements are removed. Relative order of the elements is preserved.

This function is the equivalent to std::unique.

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
Returns
End of the re-arranged sequence.

◆ Unique() [2/4]

auto maxon::Unique ( ITERABLE &&  iterable) -> decltype(begin(iterable))

Equivalent to Unique(begin(iterable), end(iterable)).

◆ Unique() [3/4]

auto maxon::Unique ( ITERATOR  first,
SENTINEL  sentinel,
COMPARE  comp 
) -> ITERATOR

Equivalent to Unique, but uses the given function to compare elements instead of the less-than operator. The sequence must be ordered by the same function. The compare function should have a signature equivalent to

Bool comp(const ElementType1&, const ElementType2&);
Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]compBinary compare function.
Returns
End of the re-arranged sequence.

◆ Unique() [4/4]

auto maxon::Unique ( ITERABLE &&  iterable,
COMPARE  comp 
) -> decltype(begin(iterable))

Equivalent to Unique(begin(iterable), end(iterable), comp).

◆ Remove() [1/2]

auto maxon::Remove ( ITERATOR  first,
SENTINEL  sentinel,
const T &  value 
) -> ITERATOR

Re-arranges elements in a sequence so that elements equal to value are removed. Relative order of the elements is preserved.

This function is the equivalent to std::remove.

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]valueThe removed value.
Returns
End of the re-arranged sequence.

◆ Remove() [2/2]

auto maxon::Remove ( ITERABLE &&  iterable,
const T &  value 
) -> decltype(begin(iterable))

Equivalent to Remove(begin(iterable), end(iterable), value).

◆ RemoveIf() [1/2]

auto maxon::RemoveIf ( ITERABLE &&  iterable,
PREDICATE  pred 
) -> decltype(begin(iterable))

Equivalent to RemoveIf(begin(iterable), end(iterable), pred).

◆ Replace() [1/2]

auto maxon::Replace ( ITERATOR  first,
SENTINEL  sentinel,
const T &  oldValue,
const T &  newValue 
) -> ITERATOR

Replaces elements in sequence [first, ...) that are equal to oldValue with copies of newValue.

This function is the equivalent to std::replace.

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]oldValueOld value.
[in]newValueNew value.
Returns
End of the modified sequence.

◆ Replace() [2/2]

auto maxon::Replace ( ITERABLE &&  iterable,
const T &  oldValue,
const T &  newValue 
) -> decltype(begin(iterable))

Equivalent to Replace(begin(iterable), end(iterable), oldValue, newValue).

◆ ReplaceIf() [1/2]

auto maxon::ReplaceIf ( ITERATOR  first,
SENTINEL  sentinel,
PREDICATE  pred,
const T &  newValue 
) -> ITERATOR

Replaces elements in sequence [first, ...) that match the given predicate with copies of newValue. The predicate function should have a signature equivalent to

Bool func(const ElementType&);

This function is the equivalent to std::replace.

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]predUnary predicate.
[in]newValueNew value.
Returns
End of the modified sequence.

◆ ReplaceIf() [2/2]

auto maxon::ReplaceIf ( ITERABLE &&  iterable,
PREDICATE  pred,
const T &  newValue 
) -> decltype(begin(iterable))

Equivalent to ReplaceIf(begin(iterable), end(iterable), pred, newValue).

◆ Fold() [1/2]

V maxon::Fold ( ITERATOR  first,
SENTINEL  sentinel,
initialValue,
BINARYOP  op 
)

Folds elements in the sequence [first, ...) from left to right with a binary function. The folding function should have a signature equivalent to

V func(const V&, const ElementType&);

This function is the equivalent to std::accumulate.

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]opFolding function.
Returns
Folded value.

◆ Fold() [2/2]

V maxon::Fold ( const ITERABLE &  iterable,
const V &  intitialValue,
BINARYOP  op 
)

Equivalent to Fold(begin(iterable), end(iterable), initialValue, op).

◆ MinElement() [1/4]

auto maxon::MinElement ( ITERATOR  first,
SENTINEL  sentinel 
) -> Optional<ITERATOR>

Finds the smallest element a sequence, or NO_VALUE if the sequence was empty. Elements must be comparable with the less-than operator.

This function is the equivalent to std::min_element.

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
Returns
Iterator to element with minimum value or NO_VALUE.

◆ MinElement() [2/4]

auto maxon::MinElement ( ITERATOR  first,
SENTINEL  sentinel,
COMPARE  comp 
) -> Optional<ITERATOR>

Equivalent to MinElement, but uses the given function to compare elements instead of the less-than operator. The comparison function should have a signature equivalent to

Bool func(const ElementType&, const ElementType&);
Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]compComparison function.
Returns
Minimum value.

◆ MinElement() [3/4]

auto maxon::MinElement ( ITERABLE &&  iterable) -> Optional<decltype(begin(iterable))>

Equivalent to MinElement(begin(iterable), end(iterable)).

◆ MinElement() [4/4]

auto maxon::MinElement ( ITERABLE &&  iterable,
COMPARE  comp 
) -> Optional<decltype(begin(iterable))>

Equivalent to MinElement(begin(iterable), end(iterable), comp).

◆ MaxElement() [1/4]

auto maxon::MaxElement ( ITERATOR  first,
SENTINEL  sentinel 
) -> Optional<ITERATOR>

Finds the largest element a sequence, or NO_VALUE if the sequence was empty. Elements must be comparable with the less-than operator.

This function is the equivalent to std::max_element.

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
Returns
Iterator to element with maximum value or NO_VALUE.

◆ MaxElement() [2/4]

auto maxon::MaxElement ( ITERATOR  first,
SENTINEL  sentinel,
COMPARE  comp 
) -> Optional<ITERATOR>

Equivalent to MaxElement, but uses the given function to compare elements instead of the less-than operator. The comparison function should have a signature equivalent to

Bool func(const ElementType&, const ElementType&);
Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]compComparison function.
Returns
Maximum value.

◆ MaxElement() [3/4]

auto maxon::MaxElement ( ITERABLE &&  iterable) -> Optional<decltype(begin(iterable))>

Equivalent to MaxElement(begin(iterable), end(iterable)).

◆ MaxElement() [4/4]

auto maxon::MaxElement ( ITERABLE &&  iterable,
COMPARE  comp 
) -> Optional<decltype(begin(iterable))>

Equivalent to MaxElement(begin(iterable), end(iterable), comp).

◆ GetSequenceLength() [1/3]

Int maxon::GetSequenceLength ( ITERATOR  first,
ITERATOR  last 
)

Returns the number of elements in a sequence [first, ... last) as Int(last - first).

◆ GetSequenceLength() [2/3]

Int maxon::GetSequenceLength ( ITERATOR  first,
SENTINEL  sentinel 
)

Equivalent to GetSequenceLength(first, last). last is determined by incrementing first until it matches the sequence delimiter sentinel.

◆ GetSequenceLength() [3/3]

Int maxon::GetSequenceLength ( const ITERABLE &  iterable)

Equivalent to GetSequenceLength(begin(iterable), end(iterable)).

◆ MAXON_ENUM_LIST() [20/113]

enum maxon::NO_MATCH_TYPE maxon::MAXON_ENUM_LIST ( NO_MATCH_TYPE  )

◆ CountIfMatch()

static auto maxon::CountIfMatch ( INDEXABLE &&  indexable,
MATCHER  matcher 
) -> Match<Int>
static

Count the #indexable elements that match the given #matcher.

using MyTup = Tuple<Int, String>;
BaseArray<MyTup> myTups;
// Search for tuple where the first member equals 2 (don't care about the value of second member).
const auto myMatcher = ByValue(2, TupleElementEquals::ByIndex<0>());
const Match<Int> countResult = CountIfMatch(myTups, myMatcher);
if (countResult.GetLength() == 1)
{
DiagnosticOutput("myTup @, first index @", myTups[countResult], countResult.GetPosition());
}
#define DiagnosticOutput(formatString,...)
Definition: debugdiagnostics.h:170
auto ByValue(const T &value) -> PredicateMatcher< ValuePredicate< T >>
Returns a value matcher for the given value.
Definition: algorithms.h:2579
static auto CountIfMatch(INDEXABLE &&indexable, MATCHER matcher) -> Match< Int >
Definition: algorithms.h:2043
Parameters
[in]indexableIndexable input container.
[in]matcherPattern matcher.
Returns
Match containing index of the first match and total match count.

◆ LinearSearch() [1/2]

auto maxon::LinearSearch ( ITERATOR  first,
SENTINEL  sentinel,
MATCHER  matcher 
) -> Match<ITERATOR>

Searches for the first occurrence of a pattern in a sequence. Different matchers allow to search for specific types of patterns, i.e. single values, sub-sequences, predicates.

Examples:

CArray<Int> values = { 40, 42, 1, 1, 2, 3 };
// Search for value 42
auto match1 = LinearSearch(values.Begin(), values.End(), ByValue(42));
if (match1)
{
auto it = match.GetPosition();
Int length = match.GetLength();
}
// Search for pattern
CArray<Int> pattern = { 1, 2, 3 };
auto match2 = LinearSearch(values, BySequence(pattern));
// Search for a value satisfying a predicate
auto match3 = LinearSearch(values, ByPredicate([] (Int v) { return v < 33; }));
PyObject PyObject * v
Definition: abstract.h:297
PyWideStringList Py_ssize_t length
Definition: initconfig.h:448
auto BySequence(const SEARCH_SEQ &searchSeq) -> SequenceMatcher< SEARCH_SEQ, maxon::details::EqualityCompare< typename std::iterator_traits< decltype(begin(searchSeq))>::value_type, typename std::iterator_traits< decltype(begin(searchSeq))>::value_type >>
Returns a sequence matcher for the given search sequence.
Definition: algorithms.h:2765
auto ByPredicate(const PRED &pred) -> PredicateMatcher< std::reference_wrapper< const PRED >>
Returns a predicate matcher for the given predicate function.
Definition: algorithms.h:2570
auto LinearSearch(ITERATOR first, SENTINEL sentinel, MATCHER matcher) -> Match< ITERATOR >
Definition: algorithms.h:2100

This function is the equivalent to std::find, std::search, ...

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]matcherPattern matcher.
Returns
Match containing iterator and length to the found subsequence.

◆ LinearSearch() [2/2]

auto maxon::LinearSearch ( ITERABLE &&  iterable,
MATCHER  matcher 
) -> Match<decltype(begin(iterable))>

Equivalent to LinearSearch(begin(iterable), end(iterable), matcher).

◆ Split()

auto maxon::Split ( const ITERABLE &  iterable,
MATCHER  matcher 
) -> Result<BaseArray<ITERABLE>>

Index-based version of LinearSearch. For an index pair (N,M) with N <= M, the input sequence is (indexable[N], indexable[N+1], ... , indexable[M-1]).

Examples:

CArray<Int> values = { 40, 42, 1, 1, 2, 3 };
// Search for value 42
auto match1 = LinearSearchIndex(values.Begin(), values.End(), ByValue(42));
if (match1)
{
Int index = match.GetPosition();
Int length = match.GetLength();
}
@param[in] indexable Indexable container.
@param[in] indexPair Start and end indices of the input sequence.
@param[in] matcher Pattern matcher.
@return Match containing index and length to the found subsequence.
//----------------------------------------------------------------------------------------
template <typename INDEXABLE, typename MATCHER>
inline auto LinearSearchIndex(const INDEXABLE& indexable, IndexPair indexPair, MATCHER matcher) -> Match<Int>
{
return matcher.FindNextIndex(indexable, indexPair);
}
//----------------------------------------------------------------------------------------
Equivalent to LinearSearchIndex(indexable, {0, GetSequenceLength(indexable)}, matcher).
//----------------------------------------------------------------------------------------
template <typename INDEXABLE, typename MATCHER>
inline auto LinearSearchIndex(const INDEXABLE& indexable, MATCHER matcher) -> Match<Int>
{
return matcher.FindNextIndex(indexable, {0, GetSequenceLength(indexable)});
}
//----------------------------------------------------------------------------------------
Splits a sequence into a variable number of parts, whereat the given matcher is used to find separators.
The parts are stored in a BaseArray and of the same type as ITERABLE.
If no separator was found in the sequence, the returned array will be empty.
To create the parts, the ITERABLE type must be constructible with
@code
using IteratorType = decltype(begin(iterable));
ITERABLE(IteratorType pos, Int length);
#define If(a0, a1, a2, a3, a4, a5, a6, a7)
Definition: Python-ast.h:514
INDEXABLE
The container implements GenericIndexableContainerInterface.
Definition: containerbase.h:10
Py_ssize_t * index
Definition: abstract.h:374
Py_ssize_t * indices
Definition: abstract.h:279
void Py_ssize_t * pos
Definition: dictobject.h:50
Int GetSequenceLength(ITERATOR first, ITERATOR last)
Returns the number of elements in a sequence [first, ... last) as Int(last - first).
Definition: algorithms.h:1872
Pair< Int, Int > IndexPair
Definition: algorithms.h:33
PyObject ** type
Definition: pycore_pyerrors.h:34
PyObject * iterable
Definition: setobject.h:72
Parameters
[in]iterableInput sequence.
[in]matcherSeparator used to divide the sequence.
Returns
BaseArray containing the parts, or error if allocation failed.

◆ SplitIndex() [1/2]

auto maxon::SplitIndex ( const INDEXABLE indexable,
IndexPair  indexPair,
MATCHER  matcher 
) -> Result<BaseArray<Match<Int>>>

Index-based version of Split. For an index pair (N,M) with N <= M, the input sequence is (indexable[N], indexable[N+1], ... , indexable[M-1]). The resulting BaseArray contains Matches, storing the index and length of each split part.

Parameters
[in]indexableIndexable container.
[in]indexPairStart and end indices of the input sequence.
[in]matcherPattern matcher.
Returns
BaseArray containing Matches, or error if allocation failed.

◆ SplitIndex() [2/2]

auto maxon::SplitIndex ( const INDEXABLE indexable,
MATCHER  matcher 
) -> Result<void>

Equivalent to SplitIndex(indexable, {0, GetSequenceLength(indexable)}, matcher).

◆ SplitToTuple()

auto maxon::SplitToTuple ( const ITERABLE &  iterable,
MATCHER  matcher 
) -> HomogenousTupleType<COUNT, ITERABLE>

Splits a sequence into COUNT parts, whereat the given matcher is used to find separators. The parts are returned in a Tuple and of the same type as ITERABLE. The split strategy is to fill in the tuple elements from left to right as long as more parts are found. This means if the number of found parts N == COUNT, each element contains exactly one part. If N < COUNT, the last COUNT - N elements are emtpy. If N > COUNT, the last element countains the additional N + COUNT parts (including separators).

To create the parts, the ITERABLE type must be constructible with

using IteratorType = decltype(begin(iterable));
ITERABLE(IteratorType pos, Int length);
Parameters
[in]iterableInput sequence.
[in]matcherSeparator used to divide the sequence.
Returns
Tuple containing split parts.

◆ SplitToTupleIndex() [1/2]

auto maxon::SplitToTupleIndex ( const INDEXABLE indexable,
IndexPair  indexPair,
MATCHER  matcher 
) -> HomogenousTupleType<COUNT, Match<Int>>

Index-based version of SplitToTuple. For an index pair (N,M) with N <= M, the input sequence is (indexable[N], indexable[N+1], ... , indexable[M-1]). The resulting Tuple contains Matches, storing the index and length of each split part.

Parameters
[in]indexableIndexable container.
[in]indexPairStart and end indices of the input sequence.
[in]matcherPattern matcher.
Returns
BaseArray containing Matches, or error if allocation failed.

◆ SplitToTupleIndex() [2/2]

auto maxon::SplitToTupleIndex ( const INDEXABLE indexable,
MATCHER  matcher 
) -> HomogenousTupleType<COUNT, Match<Int>>

Equivalent to SplitToTupleIndex(indexable, {0, GetSequenceLength(indexable)}, matcher).

◆ SplitIterate()

auto maxon::SplitIterate ( ITERATE_FUNC  iterFunc,
const ITERABLE &  iterable,
MATCHER  matcher 
) -> Result<Bool>

Iteratively splits a sequence into parts, whereat the given matcher is used to find separators. Each successive part is passed as an argument to the iterate function. The iteration terminates when all parts have been processed, or if the iteration returns false or an error. In case of an error, it's passed on as the return value.

To create the parts, the ITERABLE type must be constructible with

using IteratorType = decltype(begin(iterable));
ITERABLE(IteratorType pos, Int length);

The iteration function function should have a signature equivalent to

Bool iterFunc(const ElementType&);
Parameters
[in]iterFuncIteration function.
[in]iterableInput sequence.
[in]matcherSeparator used to divide the sequence.
Returns
True, if no iteration function returned false and at least 1 part was found, false otherwise, or an error.

◆ SplitIterateIndex() [1/2]

auto maxon::SplitIterateIndex ( ITERATE_FUNC  iterFunc,
const INDEXABLE indexable,
IndexPair  indexPair,
MATCHER  matcher 
) -> Result<Bool>

Index-based version of SplitIterateIndex. For an index pair (N,M) with N <= M, the input sequence is (indexable[N], indexable[N+1], ... , indexable[M-1]).

The iteration function function should have a signature equivalent to

Bool iterFunc(const ElementType&);
Parameters
[in]iterFuncIteration function.
[in]indexableIndexable container.
[in]indexPairStart and end indices of the input sequence.
[in]matcherPattern matcher.
Returns
True, if no iteration function returned false and at least 1 part was found, false otherwise, or an error.

◆ SplitIterateIndex() [2/2]

auto maxon::SplitIterateIndex ( ITERATE_FUNC  iterFunc,
const INDEXABLE indexable,
const MATCHER &  matcher 
) -> Result<Bool>

Equivalent to SplitIterateIndex(iterFunc, indexable, {0, GetSequenceLength(indexable)}, matcher).

◆ ByPredicate()

auto maxon::ByPredicate ( const PRED &  pred) -> PredicateMatcher<std::reference_wrapper<const PRED>>

Returns a predicate matcher for the given predicate function.

◆ ByValue() [1/2]

auto maxon::ByValue ( const T &  value) -> PredicateMatcher<ValuePredicate<T>>

Returns a value matcher for the given value.

◆ ByValue() [2/2]

auto maxon::ByValue ( const T &  value,
const COMPARE &  comp 
) -> PredicateMatcher<ValueComparePredicate<T, COMPARE>>

Returns a value matcher for the given value with a custom comparison function.

◆ ByRepeatingPredicate()

auto maxon::ByRepeatingPredicate ( const PRED &  pred) -> RepeatingPredicateMatcher<PRED>

Returns a repeating predicate matcher for the given predicate function.

◆ ByRepeatingValue() [1/2]

auto maxon::ByRepeatingValue ( const T &  value) -> RepeatingPredicateMatcher<ValuePredicate<T>>

Returns a repeating value matcher for the given value.

◆ ByRepeatingValue() [2/2]

auto maxon::ByRepeatingValue ( const T &  value,
const COMPARE &  comp 
) -> RepeatingPredicateMatcher<ValueComparePredicate<T, COMPARE>>

Returns a repeating value matcher for the given value with a custom comparison function.

◆ BySequence() [1/2]

auto maxon::BySequence ( const SEARCH_SEQ &  searchSeq) -> SequenceMatcher<SEARCH_SEQ, maxon::details::EqualityCompare<typename std::iterator_traits<decltype(begin(searchSeq))>::value_type, typename std::iterator_traits<decltype(begin(searchSeq))>::value_type>>

Returns a sequence matcher for the given search sequence.

◆ BySequence() [2/2]

auto maxon::BySequence ( const SEARCH_SEQ &  searchSeq,
const COMPARE &  comp 
) -> SequenceMatcher<SEARCH_SEQ, COMPARE>

Returns a sequence matcher for the given search sequence with a custom comparison function.

◆ SetDifference() [1/2]

auto maxon::SetDifference ( const ITERABLE1 &  firstSet,
const ITERABLE2 &  secondSet 
) -> Result<ITERABLE1>

Finds the values in the first iterable container that are not contained in the second iterable container and returns them in a container of the same type as the first container. IMPORTANT: The iterators that are retrieved from the input sets needs to iterate of the containers in a sorted order for this algorithm to work.

Parameters
[in]firstSetThe first container.
[in]secondSetThe second container.
Returns
Container of the first container type that contains all the elements of set 1 that are not contained in set 2.

◆ SetDifference() [2/2]

auto maxon::SetDifference ( const ITERABLE1 &  firstSet,
const ITERABLE2 &  secondSet,
APPENDABLE &  outContainer 
) -> Result<void>

Finds the values in the first iterable container that are not contained in the second iterable container and returns them in a container of the same type as the first container. IMPORTANT: The iterators that are retrieved from the input sets needs to iterate of the containers in a sorted order for this algorithm to work.

Parameters
[in]firstSetThe first container.
[in]secondSetThe second container.
[out]outContainerThe container that will contain the elements that are present in the first container but not the second.
Returns
OK if successful.

◆ UnorderedSetDifference() [1/2]

auto maxon::UnorderedSetDifference ( const ITERABLE &  firstSet,
const FINDABLE &  secondSet 
) -> Result<ITERABLE>

Finds the values in the first iterable container that are not contained in the second container and returns them in a container of the same type as the first container.

Parameters
[in]firstSetThe first container.
[in]secondSetThe second container, which must suppor the Contains() function.
Returns
Container of the first container type that contains all the elements of set 1 that are not contained in set 2.

◆ UnorderedSetDifference() [2/2]

auto maxon::UnorderedSetDifference ( const ITERABLE &  firstSet,
const FINDABLE &  secondSet,
APPENDABLE &  outputContainer 
) -> Result<void>

Finds the values in the first iterable container that are not contained in the second container and returns them in a container of the same type as the first container.

Parameters
[in]firstSetThe first container.
[in]secondSetThe second container, which must suppor the Contains() function.
[out]outputContainerContainer of the first container type that contains all the elements of set 1 that are not contained in set 2.
Returns
OK if successful.

◆ ExcludeSetFromSet()

auto maxon::ExcludeSetFromSet ( ERASABLE &  firstSet,
const ITERABLE &  secondSet 
) -> Result<void>

Removes the values in the first iterable container that are contained in the second container and.

Parameters
[in]firstSetThe first container which must support the Erase() member function.
[in]secondSetThe second container.
Returns
Container for the first container type that contains all the elements of set 1 that are not contained in set 2.

◆ Fill() [2/2]

auto maxon::Fill ( ITERATOR  first,
SENTINEL  sentinel,
const T &  value 
) -> ITERATOR

Assigns the given value to all elements in a sequence. The sequence is expected to contain initialized data.

This function is the equivalent to std::fill.

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]valueThe assigned value.
Returns
End of filled sequence.

◆ Reverse() [2/5]

auto maxon::Reverse ( ITERATOR  first,
ITERATOR  last 
) -> ITERATOR

Reverses the order of the elements in a sequence.

This function is the equivalent to std::reverse.

Parameters
[in]firstStart of sequence.
[in]lastEnd of sequence.
Returns
End of the reversed sequence.

◆ Reverse() [3/5]

auto maxon::Reverse ( ITERATOR  first,
SENTINEL  sentinel 
) -> ITERATOR

Equivalent to Reverse(first, last). last is determined by incrementing first until it matches the sequence delimiter sentinel.

◆ RemoveIf() [2/2]

auto maxon::RemoveIf ( ITERATOR  first,
SENTINEL  sentinel,
PREDICATE  pred 
) -> ITERATOR

Re-arranges elements in a sequence so that elements matching the given predicate are removed. Relative order of the elements is preserved. The predicate function should have a signature equivalent to

Bool func(const ElementType&);

This function is the equivalent to std::remove_if.

Parameters
[in]firstStart of sequence.
[in]sentinelSequence delimiter.
[in]predUnary predicate.
Returns
End of the re-arranged sequence.

◆ ConvertLocalDateTimeToTM()

MAXON_ATTRIBUTE_FORCE_INLINE tm maxon::ConvertLocalDateTimeToTM ( const LocalDateTime dateTime)

◆ ConvertTMToLocalDateTime()

MAXON_ATTRIBUTE_FORCE_INLINE LocalDateTime maxon::ConvertTMToLocalDateTime ( const tm st)

◆ mktime_r()

MAXON_ATTRIBUTE_FORCE_INLINE time_t maxon::mktime_r ( struct tm tm)

◆ timegm_r()

MAXON_ATTRIBUTE_FORCE_INLINE time_t maxon::timegm_r ( struct tm tm)

◆ MAXON_ENUM_ORDERED_FLAGS() [1/2]

enum maxon::VALUEKIND UInt64 maxon::MAXON_ENUM_ORDERED_FLAGS ( VALUEKIND  ,
"net.maxon.datatype.enum.valuekind"  ,
EARLY   
)

◆ MAXON_ENUM_LIST() [21/113]

enum maxon::COLLECTION_KIND maxon::MAXON_ENUM_LIST ( COLLECTION_KIND  )

◆ __attribute__()

maxon::__attribute__ ( (always_inline)  ) &&

◆ PrivateGetDataType() [1/19]

Result<DataType> maxon::PrivateGetDataType ( ArrayInterface< T > **  ,
OverloadRank0   
)

◆ MAXON_IMPLEMENTATION_SIMPLE_REGISTER() [1/5]

maxon::MAXON_IMPLEMENTATION_SIMPLE_REGISTER ( ArrayImpl< ARRAY >  )

◆ ToArrayPtr()

const ArrayInterface<T>* maxon::ToArrayPtr ( const ArrayInterface< T > &  array)

Returns a pointer to the array reference argument. This function is useful if you have to convert some array to a pointer to an ArrayInterface:

void Func(const ArrayInterface<const Char>* array);
BlockArray<Char> myArray;
Func(ToArrayPtr(myArray));
const ArrayInterface< T > * ToArrayPtr(const ArrayInterface< T > &array)
Definition: array.h:2081

For WritableArrayInterface parameters, use ToWritableArrayPtr instead.

See also
ArrayInterface.
Template Parameters
TType of elements of the array, this is deduced by the compiler.
Note
If the argument is a temporary (which usually is the case), the result will be a pointer to a temporary. Make sure that the pointer is used only within the lifetime of the temporary. For the above example, it suffices that Func uses the array only during its execution.

◆ ToWritableArrayPtr()

WritableArrayInterface<T>* maxon::ToWritableArrayPtr ( WritableArrayInterface< T > &  array)

Returns a pointer to the array reference argument. This function is useful if you have to convert some array to a pointer to an ArrayInterface:

void Func(WritableArrayInterface<const Char>* array);
BlockArray<Char> myArray;
Func(ToWritableArrayPtr(myArray));
WritableArrayInterface< T > * ToWritableArrayPtr(WritableArrayInterface< T > &array)
Definition: array.h:2106

For non-modifiable array parameters, use ToArrayPtr instead.

See also
ArrayInterface.
Template Parameters
TType of elements of the array, this is deduced by the compiler.
Note
If the argument is a temporary (which usually is the case), the result will be a pointer to a temporary. Make sure that the pointer is used only within the lifetime of the temporary. For the above example, it suffices that Func uses the array only during its execution.

◆ MAXON_DATATYPE() [18/73]

maxon::MAXON_DATATYPE ( BackgroundEntryTuple  ,
"net.maxon.datatyoe.backgroundentrytuple"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ MAXON_DATATYPE() [19/73]

maxon::MAXON_DATATYPE ( BitSet  ,
"net.maxon.datatype.bitset"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ ConstExprStringsAreEqual()

constexpr Bool maxon::ConstExprStringsAreEqual ( const Char str1,
const Char str2 
)
constexpr

◆ MAXON_ENUM_LIST() [22/113]

enum maxon::BYTEORDER maxon::MAXON_ENUM_LIST ( BYTEORDER  )

◆ SwapByteOrder() [1/6]

MAXON_ATTRIBUTE_FORCE_INLINE UInt16 maxon::SwapByteOrder ( UInt16  data)

Swaps the memory layout of a value from big to little endian or vice versa.

Parameters
[in]dataValue that will be swapped.
Returns
Swapped value.

◆ SwapByteOrder() [2/6]

MAXON_ATTRIBUTE_FORCE_INLINE Int16 maxon::SwapByteOrder ( Int16  data)

Swaps the memory layout of a value from big to little endian or vice versa.

Parameters
[in]dataValue that will be swapped.
Returns
Swapped value.

◆ SwapByteOrder() [3/6]

MAXON_ATTRIBUTE_FORCE_INLINE UInt32 maxon::SwapByteOrder ( UInt32  data)

Swaps the memory layout of a value from big to little endian and vice versa.

Parameters
[in]dataValue that will be swapped.
Returns
Swapped value.

◆ SwapByteOrder() [4/6]

MAXON_ATTRIBUTE_FORCE_INLINE Int32 maxon::SwapByteOrder ( Int32  data)

Swaps the memory layout of a value from big to little endian or vice versa.

Parameters
[in]dataValue that will be swapped.
Returns
Swapped value.

◆ SwapByteOrder() [5/6]

MAXON_ATTRIBUTE_FORCE_INLINE UInt64 maxon::SwapByteOrder ( UInt64  data)

Swaps the memory layout of a value from big to little endian and vice versa.

Parameters
[in]dataValue that will be swapped.
Returns
Swapped value.

◆ SwapByteOrder() [6/6]

MAXON_ATTRIBUTE_FORCE_INLINE Int64 maxon::SwapByteOrder ( Int64  data)

Swaps the memory layout of a value from big to little endian or vice versa.

Parameters
[in]dataValue that will be swapped.
Returns
Swapped value.

◆ SwapUInt16() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE UInt16 maxon::SwapUInt16 ( UInt16  data)

Swaps the memory layout of a value from big to little endian or vice versa.

Parameters
[in]dataValue that will be swapped.
Returns
Swapped value.

◆ SwapInt16() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Int16 maxon::SwapInt16 ( Int16  data)

Swaps the memory layout of a value from big to little endian or vice versa.

Parameters
[in]dataValue that will be swapped.
Returns
Swapped value.

◆ SwapUInt32() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE UInt32 maxon::SwapUInt32 ( UInt32  data)

Swaps the memory layout of a value from big to little endian or vice versa.

Parameters
[in]dataValue that will be swapped.
Returns
Swapped value.

◆ SwapInt32() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Int32 maxon::SwapInt32 ( Int32  data)

Swaps the memory layout of a value from big to little endian or vice versa.

Parameters
[in]dataValue that will be swapped.
Returns
Swapped value.

◆ SwapUInt64() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE UInt64 maxon::SwapUInt64 ( UInt64  data)

Swaps the memory layout of a value from big to little endian or vice versa.

Parameters
[in]dataValue that will be swapped.
Returns
Swapped value.

◆ SwapInt64() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Int64 maxon::SwapInt64 ( Int64  data)

Swaps the memory layout of a value from big to little endian or vice versa.

Parameters
[in]dataValue that will be swapped.
Returns
Swapped value.

◆ SwapUInt16() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::SwapUInt16 ( UInt16 addr,
Int  count = 1 
)

Swaps the memory layout of multiple values from big to little endian and vice versa.

Parameters
[in]addrPointer to elements that will be swapped.
[in]countNumber of elements that will be swapped.

◆ SwapInt16() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::SwapInt16 ( Int16 addr,
Int  count = 1 
)

Swaps the memory layout of multiple values from big to little endian and vice versa.

Parameters
[in]addrPointer to elements that will be swapped.
[in]countNumber of elements that will be swapped.

◆ SwapUInt32() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::SwapUInt32 ( UInt32 addr,
Int  count = 1 
)

Swaps the memory layout of multiple values from big to little endian and vice versa.

Parameters
[in]addrPointer to elements that will be swapped.
[in]countNumber of elements that will be swapped.

◆ SwapInt32() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::SwapInt32 ( Int32 addr,
Int  count = 1 
)

Swaps the memory layout of multiple values from big to little endian and vice versa.

Parameters
[in]addrPointer to elements that will be swapped.
[in]countNumber of elements that will be swapped.

◆ SwapUInt64() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::SwapUInt64 ( UInt64 addr,
Int  count = 1 
)

Swaps the memory layout of multiple values from big to little endian and vice versa.

Parameters
[in]addrPointer to elements that will be swapped.
[in]countNumber of elements that will be swapped.

◆ SwapInt64() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::SwapInt64 ( Int64 addr,
Int  count = 1 
)

Swaps the memory layout of multiple values from big to little endian and vice versa.

Parameters
[in]addrPointer to elements that will be swapped.
[in]countNumber of elements that will be swapped.

◆ ByteOrder_UInt16()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ByteOrder_UInt16 ( UInt16 addr,
Int  count = 1 
)

Converts from a given byte order to the current system's byte order and vice versa. If the byte order matches the system's byte order nothing will be done.

Template Parameters
orderByte order of the data.
Parameters
[in]addrPointer to the data.
[in]countNumber of elements.

◆ ByteOrder_Int16()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ByteOrder_Int16 ( Int16 addr,
Int  count = 1 
)

Converts from a given byte order to the current system's byte order and vice versa. If the byte order matches the system's byte order nothing will be done.

Template Parameters
orderByte order of the data.
Parameters
[in]addrPointer to the data.
[in]countNumber of elements.

◆ ByteOrder_UInt32()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ByteOrder_UInt32 ( UInt32 addr,
Int  count = 1 
)

Converts from a given byte order to the current system's byte order and vice versa. If the byte order matches the system's byte order nothing will be done.

Template Parameters
orderByte order of the data.
Parameters
[in]addrPointer to the data.
[in]countNumber of elements.

◆ ByteOrder_Int32()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ByteOrder_Int32 ( Int32 addr,
Int  count = 1 
)

Converts from a given byte order to the current system's byte order and vice versa. If the byte order matches the system's byte order nothing will be done.

Template Parameters
orderByte order of the data.
Parameters
[in]addrPointer to the data.
[in]countNumber of elements.

◆ ByteOrder_UInt64()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ByteOrder_UInt64 ( UInt64 addr,
Int  count = 1 
)

Converts from a given byte order to the current system's byte order and vice versa. If the byte order matches the system's byte order nothing will be done.

Template Parameters
orderByte order of the data.
Parameters
[in]addrPointer to the data.
[in]countNumber of elements.

◆ ByteOrder_Int64()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ByteOrder_Int64 ( Int64 addr,
Int  count = 1 
)

Converts from a given byte order to the current system's byte order and vice versa. If the byte order matches the system's byte order nothing will be done.

Template Parameters
orderByte order of the data.
Parameters
[in]addrPointer to the data.
[in]countNumber of elements.

◆ MAXON_DATATYPE() [20/73]

maxon::MAXON_DATATYPE ( BytesValue  ,
"net.maxon.datatype.bytesvalue"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ ScanParameter() [1/2]

void maxon::ScanParameter ( BytesValue res,
const Block< const Utf32Char > &  str,
Int processed,
const String formatStatement,
Bool error 
)

Helper function to use ScanString ScanParameter description. Do not call on your own! Usage:

BytesValue bytes;
String valueStr = "20MB"_s;
Bool res = ScanString(valueStr, "@", bytes);
Definition: c4d_string.h:41
void const void * bytes
Definition: bytesobject.h:117
Py_UCS4 * res
Definition: unicodeobject.h:1113
Bool ScanString(STR inputStr, STR2 formatStr, ARGS &... args)
Definition: string.h:2214

◆ MAXON_ENUM_LIST() [23/113]

enum maxon::CONFIGURATION_CATEGORY maxon::MAXON_ENUM_LIST ( CONFIGURATION_CATEGORY  )

◆ MAXON_ENUM_LIST() [24/113]

◆ MAXON_ENUM_LIST() [25/113]

enum maxon::CONFIGURATIONENTRY_STATE maxon::MAXON_ENUM_LIST ( CONFIGURATIONENTRY_STATE  )

◆ MAXON_DATATYPE() [21/73]

maxon::MAXON_DATATYPE ( ConfigInit  ,
"net.maxon.datatype.configinit"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ MAXON_DEPENDENCY() [1/2]

maxon::MAXON_DEPENDENCY ( configuration  )

◆ QueryConfigBool()

Bool maxon::QueryConfigBool ( const String symbol)

◆ MAXON_DATATYPE() [22/73]

maxon::MAXON_DATATYPE ( ConstData  ,
"net.maxon.datatype.constdata"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ PrivateGetDataType() [2/19]

ResultOk<const ContainerDataType<T...>&> maxon::PrivateGetDataType ( ContainerInterface< T... > **  ,
OverloadRank1   
)

◆ PrivateGetDataType() [3/19]

Result<DataType> maxon::PrivateGetDataType ( RecursiveContainer< DEPTH > **  ,
OverloadRank0   
)

◆ MAXON_DEPENDENCY() [2/2]

maxon::MAXON_DEPENDENCY ( cpuidinit  )

◆ operator==() [1/8]

MAXON_ATTRIBUTE_FORCE_INLINE bool maxon::operator== ( const CustomSTLAllocator< T1 > &  ,
const CustomSTLAllocator< T2 > &   
)
noexcept

◆ operator!=() [1/7]

MAXON_ATTRIBUTE_FORCE_INLINE bool maxon::operator!= ( const CustomSTLAllocator< T1 > &  ,
const CustomSTLAllocator< T2 > &   
)
noexcept

◆ MAXON_REGISTRY() [23/64]

maxon::MAXON_REGISTRY ( DataType  ,
LegacyDataTypeIdentifiers  ,
"net.maxon.registry.datatype.legacyidentifiers"   
)

This extension point allows to declare new DataType to be used with deprecated identifiers. Register any deprecated type that needs to be converted with this line: MAXON_DECLARATION_REGISTER(maxon::LegacyDataTypeIdentifiers, "net.maxon.mograph.legacyshadingdata") { return GetDataType<NewShadingData>(); }

◆ MAXON_DATATYPE() [23/73]

maxon::MAXON_DATATYPE ( LanguageStringDataDescription  ,
"net.maxon.datatype.languagestringdatadescription"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ MAXON_DATATYPE() [24/73]

maxon::MAXON_DATATYPE ( VariadicIdsElement  ,
"net.maxon.datatype.variadicidselement"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ AddResourceDefault() [1/2]

Result<void> maxon::AddResourceDefault ( DataDictionary &  props,
const T &  t,
OverloadRank0   
)

◆ AddResourceDefault() [2/2]

SFINAEHelper<Result<void>, typename T::HasDefault>::type maxon::AddResourceDefault ( DataDictionary &  props,
const T &  t,
OverloadRank1   
)

◆ BlockToEnumArray()

Result<BaseArray<Tuple<Id, Data> > > maxon::BlockToEnumArray ( const Block< TYPE > &  enumBlock)

Converts a given Block<TYPE> to a enum list array to use with DESCRIPTION::DATA::BASE::ENUM.

Parameters
[in]enumBlockBlock to convert into a array.
Returns
BaseArray on success.

◆ AddResourceProperty()

Result<void> maxon::AddResourceProperty ( DataDescription &  description,
const T &  t,
const Delegate< Result< void >(DataDictionary &props)> &  addProps = nullptr 
)

◆ EraseResourceProperty()

Result<void> maxon::EraseResourceProperty ( DataDescription &  description,
const T &  t 
)

◆ MAXON_ENUM_LIST() [26/113]

enum maxon::CONDITIONTOKENTYPE maxon::MAXON_ENUM_LIST ( CONDITIONTOKENTYPE  )

◆ MAXON_DATATYPE() [25/73]

maxon::MAXON_DATATYPE ( ProcessEnumListDelegate  ,
"net.maxon.datatype.processenumlistdelegate"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ MAXON_REGISTRY() [24/64]

maxon::MAXON_REGISTRY ( ProcessEnumListDelegate  ,
ProcessEnumListDelegates  ,
"net.maxon.datadescription.registry.processenumlist"   
)

GetEffectiveEnumList will utilize this registry to replace extension points.

◆ MAXON_DATATYPE() [26/73]

maxon::MAXON_DATATYPE ( EnumVariableResolveDelegate  ,
"net.maxon.datatype.delegate.enumvariableresolve"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ MAXON_REGISTRY() [25/64]

maxon::MAXON_REGISTRY ( EnumVariableResolveDelegate  ,
EnumVariableResolveDelegates  ,
"net.maxon.datadescription.registry.enumvariableresolve"   
)

GetEffectiveEnumList will utilize this registry to resolve enums and presets which need their identifier to be resolved before use. For instance, "net.maxon.description.base.preset.{re_selectedtype}" must be resolved to something like "net.maxon.description.base.preset.float" to fetch the correct preset database.

See also
VARIABLEID_PREFIX.

◆ UseFilterData()

Bool maxon::UseFilterData ( const Data filterData,
const Data compare 
)

Helper function to use with ProcessEnumListDelegate to verify if a type needs to be added to the output array.

Parameters
[in]filterDataForward filterData from delegate.
[in]compareData that would be added. check before doing more complex operations.
Returns
True to process the data, false to ignore this entry.

◆ MAXON_ENUM_FLAGS() [8/34]

enum maxon::GETDATAFLAGS maxon::MAXON_ENUM_FLAGS ( GETDATAFLAGS  )

◆ MAXON_DECLARATION() [20/89]

maxon::MAXON_DECLARATION ( Class< DataDescriptionDefinition >  ,
DataDescriptionDefinitionClass  ,
"net.maxon.class.datadescriptiondefinition"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

Implementation of the DataDictionaryObjectInterface without any data stored. This class can be used as a base component for you own inherited classes which overrides SetData/GetData.

◆ MAXON_DATATYPE() [27/73]

maxon::MAXON_DATATYPE ( LanguageStringDataDescriptionDefinition  ,
"net.maxon.datatype.languagestringdatadescriptiondefinition"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ MAXON_ENUM_ORDERED_LIST() [1/2]

enum maxon::DBVERSION maxon::MAXON_ENUM_ORDERED_LIST ( DBVERSION  )

◆ MAXON_ENUM_FLAGS() [9/34]

◆ MAXON_DATATYPE() [28/73]

maxon::MAXON_DATATYPE ( DescriptionMessageCall  ,
"net.maxon.datatype.descriptionmessagecall"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ MAXON_ENUM_LIST() [27/113]

enum maxon::LOADDESCRIPTIONMODE maxon::MAXON_ENUM_LIST ( LOADDESCRIPTIONMODE  )

◆ MAXON_DECLARATION() [21/89]

maxon::MAXON_DECLARATION ( Class< DataDescriptionObjectRef >  ,
DataDescriptionObjectClass  ,
"net.maxon.class.datadescriptionobject"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ MAXON_REGISTRY() [26/64]

maxon::MAXON_REGISTRY ( DataFormatReaderFactory  ,
DataFormatReaderFactories  ,
"net.maxon.registry.dataformatreaderfactories"   
)

Registry to register/iterate all available DataSerialize Reader implementations.

◆ MAXON_REGISTRY() [27/64]

maxon::MAXON_REGISTRY ( DataFormatWriterFactory  ,
DataFormatWriterFactories  ,
"net.maxon.registry.dataformatwriterfactories"   
)

Registry to register/iterate all available DataSerialize Writer implementations.

◆ MAXON_DECLARATION() [22/89]

maxon::MAXON_DECLARATION ( Class< DataFormatWriterRef >  ,
DataFormatWriterBinaryClass  ,
"net.maxon.class.dataformatwriterbinary"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ MAXON_DECLARATION() [23/89]

maxon::MAXON_DECLARATION ( Class< DataFormatWriterRef >  ,
DataFormatWriterJsonClass  ,
"net.maxon.class.dataformatwriterjson"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ MAXON_DECLARATION() [24/89]

maxon::MAXON_DECLARATION ( Class< DataFormatWriterRef >  ,
DataFormatWriterXmlClass  ,
"net.maxon.class.dataformatwriterxml"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ MAXON_DECLARATION() [25/89]

maxon::MAXON_DECLARATION ( Class< DataFormatReaderRef >  ,
DataFormatReaderBinaryClass  ,
"net.maxon.class.dataformatreaderbinary"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ MAXON_DECLARATION() [26/89]

maxon::MAXON_DECLARATION ( Class< DataFormatReaderRef >  ,
DataFormatReaderJsonClass  ,
"net.maxon.class.dataformatreaderjson"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ MAXON_DECLARATION() [27/89]

maxon::MAXON_DECLARATION ( Class< DataFormatReaderRef >  ,
DataFormatReaderXmlClass  ,
"net.maxon.class.dataformatreaderxml"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ MAXON_DATATYPE() [29/73]

maxon::MAXON_DATATYPE ( IDENT_VOID  ,
"net.maxon.ident_void"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ CreateHelper()

ResultPtr<void> maxon::CreateHelper ( )

◆ DeleteHelper()

void maxon::DeleteHelper ( void *  helper)

◆ ReadHelper()

Result<void> maxon::ReadHelper ( DataSerializeInterface ds,
void *  classPtr,
void *  helperPtr,
UInt  elementHash 
)

◆ WriteHelper()

Result<void> maxon::WriteHelper ( DataSerializeInterface ds,
void *  classPtr,
void *  helperPtr,
UInt  elementHash 
)

◆ ArrayConversionHelper()

void maxon::ArrayConversionHelper ( void *  arrayPtr,
Char memBuffer 
)

◆ SetConversionHelper()

void maxon::SetConversionHelper ( void *  mapPtr,
Char memBuffer 
)

◆ MapConversionHelper()

void maxon::MapConversionHelper ( void *  mapPtr,
Char memBuffer 
)

◆ operator|()

DESCRIBEFLAGS maxon::operator| ( DESCRIBEFLAGS  a,
DESCRIBEFLAGS  b 
)

◆ operator&()

DESCRIBEFLAGS maxon::operator& ( DESCRIBEFLAGS  a,
DESCRIBEFLAGS  b 
)

◆ operator~()

DESCRIBEFLAGS maxon::operator~ ( DESCRIBEFLAGS  a)

◆ operator&=()

DESCRIBEFLAGS& maxon::operator&= ( DESCRIBEFLAGS a,
DESCRIBEFLAGS  b 
)

◆ MAXON_ENUM_FLAGS() [10/34]

enum maxon::PREPAREHELPERFLAGS maxon::MAXON_ENUM_FLAGS ( PREPAREHELPERFLAGS  )

◆ MAXON_DECLARATION() [28/89]

maxon::MAXON_DECLARATION ( Class< DataSerializeRef >  ,
DataSerializeBaseClass  ,
"net.maxon.class.dataserializebase"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

Default implementation of DataSerializeInterface.

◆ MAXON_DECLARATION() [29/89]

maxon::MAXON_DECLARATION ( Class< DataSerializeReaderRef >  ,
DataSerializeReaderClass  ,
"net.maxon.class.dataserializereader"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

Default implementation of DataSerializeReaderInterface.

◆ MAXON_DECLARATION() [30/89]

maxon::MAXON_DECLARATION ( Class< DataSerializeWriterRef >  ,
DataSerializeWriterClass  ,
"net.maxon.class.dataserializewriter"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

Default implementation of DataSerializeWriterInterface.

◆ PrivateGetDataType() [4/19]

std::enable_if<STD_IS_REPLACEMENT(enum, T), ResultOk<const DataType&> >::type maxon::PrivateGetDataType ( T **  ,
OverloadRank0   
)

◆ PrivateGetDataType() [5/19]

std::enable_if<GetDirectlyReferencedType<T>::value, Result<DataType> >::type maxon::PrivateGetDataType ( T **  ,
OverloadRank0   
)

◆ PrivateGetDataType() [6/19]

SFINAEHelper<Result<DataType>, typename T::VectorStrideType>::type maxon::PrivateGetDataType ( T **  ,
OverloadRank0   
)

◆ MAXON_DATATYPE_EARLY_ENUM() [1/7]

maxon::MAXON_DATATYPE_EARLY_ENUM ( WRITEMETA  ,
"net.maxon.datatype.enum.writemeta"   
)

◆ MAXON_DATATYPE_EARLY_ENUM() [2/7]

maxon::MAXON_DATATYPE_EARLY_ENUM ( TARGETAUDIENCE  ,
"net.maxon.datatype.enum.targetaudience"   
)

◆ MAXON_DATATYPE_EARLY_ENUM() [3/7]

maxon::MAXON_DATATYPE_EARLY_ENUM ( OUTPUT  ,
"net.maxon.datatype.enum.output"   
)

◆ MAXON_DATATYPE_EARLY_ENUM() [4/7]

maxon::MAXON_DATATYPE_EARLY_ENUM ( VALUEKIND  ,
"net.maxon.datatype.enum.valuekind"   
)

◆ MAXON_DATATYPE_EARLY_ENUM() [5/7]

maxon::MAXON_DATATYPE_EARLY_ENUM ( COMPARERESULT  ,
"net.maxon.datatype.enum.compareresult"   
)

◆ MAXON_DATATYPE_EARLY_ENUM() [6/7]

maxon::MAXON_DATATYPE_EARLY_ENUM ( EQUALITY  ,
"net.maxon.datatype.enum.equality"   
)

◆ MAXON_DATATYPE_EARLY_ENUM() [7/7]

maxon::MAXON_DATATYPE_EARLY_ENUM ( COLLECTION_RESIZE_FLAGS  ,
"net.maxon.datatype.enum.collection_resize_flags"   
)

◆ MAXON_ENUM_LIST() [28/113]

enum maxon::DATATYPEBUILDERNAME maxon::MAXON_ENUM_LIST ( DATATYPEBUILDERNAME  )

◆ MAXON_DATATYPE() [30/73]

maxon::MAXON_DATATYPE ( DataTypeBuilderEntry  ,
"net.maxon.datatype.datatypebuilderentry"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ MAXON_REGISTRY() [28/64]

maxon::MAXON_REGISTRY ( DataTypeBuilderEntry  ,
DataTypeBuilderRegistry  ,
"net.maxon.registry.datatypebuilderregistry"   
)

◆ MAXON_ENUM_LIST() [29/113]

enum maxon::DAYOFWEEK maxon::MAXON_ENUM_LIST ( DAYOFWEEK  )

◆ MAXON_ENUM_LIST() [30/113]

enum maxon::DST Int16 maxon::MAXON_ENUM_LIST ( DST  )

◆ MAXON_ENUM_LIST() [31/113]

enum maxon::JULIANDATE maxon::MAXON_ENUM_LIST ( JULIANDATE  )

◆ MAXON_DATATYPE() [31/73]

maxon::MAXON_DATATYPE ( UniversalDateTime  ,
"net.maxon.datatype.universaldatetime"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ MAXON_DATATYPE() [32/73]

maxon::MAXON_DATATYPE ( LocalDateTime  ,
"net.maxon.datatype.localdatetime"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ ScanParameter() [2/2]

void maxon::ScanParameter ( UniversalDateTime res,
const Block< const Utf32Char > &  str,
Int processed,
const String formatStatement,
Bool error 
)

Helper function to use ScanString ScanParameter description. Do not call on your own! Usage:

UniversalDateTime date;
String valueStr = "2020-10-23"_s;
Bool res = ScanString(valueStr, "@", date);

◆ MAXON_ENUM_LIST() [32/113]

enum maxon::HARDWAREBREAKPOINTTYPE maxon::MAXON_ENUM_LIST ( HARDWAREBREAKPOINTTYPE  )

◆ MAXON_ENUM_LIST() [33/113]

enum maxon::HARDWAREBREAKPOINTSIZE maxon::MAXON_ENUM_LIST ( HARDWAREBREAKPOINTSIZE  )

◆ sprintf_safe()

Int maxon::sprintf_safe ( Char _DstBuf,
Int  _MaxCount,
const Char _Format,
  ... 
)

◆ MAXON_DECLARATION() [31/89]

maxon::MAXON_DECLARATION ( ComponentDescriptor  ,
EagerDecoratorComponent  ,
"net.maxon.component.eagerdecorator"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ MAXON_DECLARATION() [32/89]

maxon::MAXON_DECLARATION ( ComponentDescriptor  ,
WeakDecoratorComponent  ,
"net.maxon.component.weakdecorator"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ _ReallocMem()

MAXON_ATTRIBUTE_FORCE_INLINE ResultPtr<T> maxon::_ReallocMem ( T *  p,
Int  cnt,
MAXON_SOURCE_LOCATION_DECLARATION   
)

Resizes a raw memory block : no constructors are called! The content of the memory block is preserved up to the lesser of the new and old sizes, even if the block is moved to a new location. The additional memory is not cleared, it may contain a certain byte pattern in debug mode. In case that p is a nullptr the function behaves like NewMem. If the function fails to allocate the requested block of memory a nullptr is returned and the memory block pointed to by argument p is not deallocated (it is still valid with its contents unchanged). THREADSAFE.

Parameters
[in]pCurrent memory block (can be nullptr)
[in]cntNew number of items (size of the memory block is n * sizeof(T))
[in]allocLocationPass MAXON_SOURCE_LOCATION(_NAME) to add the current source line and file.
Returns
Memory block address or nullptr if resize is not possible (p is still valid in this case)

◆ DeleteMem()

void maxon::DeleteMem ( T *&  p)

Frees a raw memory block: no destructors are called! THREADSAFE.

Parameters
[in]pMemory block (can be nullptr, will be nullptr after return)

◆ DeleteConstPtrMem()

void maxon::DeleteConstPtrMem ( const void *  p)

Frees a raw memory block: no destructors are called! Normally you should use DeleteMemj(). This variant should be used only in the rare case when the object pointer is a constant so that it can't be set to nullptr. THREADSAFE.

Parameters
[in]pMemory block (can be nullptr).

◆ MemCopy()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::MemCopy ( void *  dst,
const void *  src,
Int  size 
)

Copies raw memory if size >0; source and destination pointers are tested against nullptr source and destination memory must not overlap THREADSAFE.

Parameters
[out]dstMemory destination.
[in]srcMemory source.
[in]sizeNumber of bytes to be copied.

◆ MemMove()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::MemMove ( void *  dst,
const void *  src,
Int  size 
)

Moves raw memory if size >0; source and destination pointers are tested against nullptr source and destination memory may overlap THREADSAFE.

Parameters
[out]dstMemory destination.
[in]srcMemory source.
[in]sizeNumber of bytes to be moved.

◆ MemCopyType()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::MemCopyType ( T *  dst,
const T *  src,
Int  cnt 
)

Copies the content of a datatype to another of the same kind source and destination memory must not overlap THREADSAFE.

Parameters
[out]dstDestination address of datatype.
[in]srcSource address of datatype.
[in]cntNumber of elements to be copied (>1 e.g. for arrays), can be 0.

◆ MemMoveType()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::MemMoveType ( T *  dst,
const T *  src,
Int  cnt 
)

Moves the content of a datatype to another of the same kind source and destination memory may overlap THREADSAFE.

Parameters
[out]dstDestination address of datatype.
[in]srcSource address of datatype.
[in]cntNumber of elements to be copied (>1 e.g. for arrays), can be 0.

◆ ClearMem()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ClearMem ( void *  mem,
Int  size,
UChar  value = 0 
)

Clears memory with pattern, if size >0. THREADSAFE.

Parameters
[out]memMemory.
[in]sizeNumber of bytes to be filled with pattern, must be greater or equal to 0.
[in]valueOptional, 1-byte value defining the pattern (default: 0)

◆ SecureClearMem()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::SecureClearMem ( volatile void *  mem,
Int  size,
UChar  value = 0 
)

Clears memory with pattern, if size >0. The compiler might remove calls to ClearMem during optimization when the memory is not read from afterwards. To securely clear the memory block use SecureClearMem. THREADSAFE.

Parameters
[out]memMemory.
[in]sizeNumber of bytes to be filled with pattern, must be greater or equal to 0.
[in]valueOptional, 1-byte value defining the pattern (default: 0)

◆ CompareMem()

MAXON_ATTRIBUTE_FORCE_INLINE Int maxon::CompareMem ( const void *  block1,
const void *  block2,
Int  size 
)

Compares two memory blocks THREADSAFE.

Parameters
[in]block1Address of first memory block.
[in]block2Address of second memory block.
[in]sizeNumber of bytes to compare, must be greater or equal to 0.
Returns
Zero, if the memory blocks match, or a value different from zero representing which is greater if they do not.

◆ ClearMemType()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ClearMemType ( T *  data_ptr,
Int  cnt,
UChar  value = 0 
)

Clears memory of a datatype with pattern, if size >0. THREADSAFE.

Parameters
[out]data_ptrAddress of the datatype.
[in]cntNumber of elements t be filled with pattern (>1 e.g. for arrays), can be 0.
[in]value(optional) fill value.

◆ MAXON_MEMBERTYPE_DETECTOR() [1/4]

maxon::MAXON_MEMBERTYPE_DETECTOR ( IsArrayAllocator  ,
IsArrayAllocator  ,
std::false_type   
)

◆ PrivateConstRefDefaultValue()

MAXON_ATTRIBUTE_FORCE_INLINE const T& maxon::PrivateConstRefDefaultValue ( T *  ,
OverloadRank0   
)

◆ PrivateConstRefDefaultValueHelper() [1/3]

MAXON_ATTRIBUTE_FORCE_INLINE const T& maxon::PrivateConstRefDefaultValueHelper ( OverloadRank0  )

◆ PrivateConstRefDefaultValueHelper() [2/3]

MAXON_ATTRIBUTE_FORCE_INLINE DefaultValueDetector<const T&, &T::DefaultValue>::type maxon::PrivateConstRefDefaultValueHelper ( OverloadRank1  )

◆ PrivateConstRefDefaultValueHelper() [3/3]

MAXON_ATTRIBUTE_FORCE_INLINE DefaultValueDetector<const T&, &T::DefaultValueRef>::type maxon::PrivateConstRefDefaultValueHelper ( OverloadRank2  )

◆ PrivateDefaultValueHelper() [1/3]

MAXON_ATTRIBUTE_FORCE_INLINE T maxon::PrivateDefaultValueHelper ( OverloadRank0  )

◆ PrivateDefaultValueHelper() [2/3]

MAXON_ATTRIBUTE_FORCE_INLINE DefaultValueDetector<T, &T::DefaultValue>::type maxon::PrivateDefaultValueHelper ( OverloadRank1  )

◆ PrivateDefaultValueHelper() [3/3]

MAXON_ATTRIBUTE_FORCE_INLINE DefaultValueDetector<const T&, &T::DefaultValue>::type maxon::PrivateDefaultValueHelper ( OverloadRank1  )

◆ PrivateDefaultValueDispatcher() [1/3]

MAXON_ATTRIBUTE_FORCE_INLINE T maxon::PrivateDefaultValueDispatcher ( OverloadRank0  )

◆ PrivateDefaultValueDispatcher() [2/3]

MAXON_ATTRIBUTE_FORCE_INLINE SFINAEHelper<T, typename DefaultValueFunctions<typename std::decay<T>::type>::Default>::type maxon::PrivateDefaultValueDispatcher ( OverloadRank1  )

◆ PrivateDefaultValueDispatcher() [3/3]

MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if<IsZeroInitialized<typename std::decay<T>::type>::value || STD_IS_REPLACEMENT(same, typename std::decay<T>::type, Generic), T>::type maxon::PrivateDefaultValueDispatcher ( OverloadRank2  )

◆ DefaultValue< void, false >()

◆ MAXON_ENUM_LIST() [34/113]

enum maxon::NULL_RETURN_REASON maxon::MAXON_ENUM_LIST ( NULL_RETURN_REASON  )

◆ PrivateGetNullReturnError()

ThreadReferencedError maxon::PrivateGetNullReturnError ( NULL_RETURN_REASON  reason)

◆ PrivateLogNullptrError() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::PrivateLogNullptrError ( )

◆ PrivateLogNullptrError() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Bool maxon::PrivateLogNullptrError ( Bool  result)

◆ PrivateDefaultReturnValue() [1/5]

MAXON_ATTRIBUTE_FORCE_INLINE T maxon::PrivateDefaultReturnValue ( NULL_RETURN_REASON  reason,
OverloadRank0   
)

◆ PrivateDefaultReturnValue() [2/5]

MAXON_ATTRIBUTE_FORCE_INLINE SFINAEHelper<T, typename DefaultValueFunctions<typename std::decay<T>::type>::Default>::type maxon::PrivateDefaultReturnValue ( NULL_RETURN_REASON  reason,
OverloadRank1   
)

◆ PrivateDefaultReturnValue() [3/5]

MAXON_ATTRIBUTE_FORCE_INLINE SFINAEHelper<T, typename DefaultValueFunctions<typename std::decay<T>::type>::ResultMarker>::type maxon::PrivateDefaultReturnValue ( NULL_RETURN_REASON  reason,
OverloadRank2   
)

◆ PrivateDefaultReturnValue() [4/5]

MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if<STD_IS_REPLACEMENT(same, Id, typename std::decay<T>::type), T>::type maxon::PrivateDefaultReturnValue ( NULL_RETURN_REASON  reason,
OverloadRank3   
)

◆ PrivateDefaultReturnValue() [5/5]

MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if<IsZeroInitialized<typename std::decay<T>::type>::value || STD_IS_REPLACEMENT(same, typename std::decay<T>::type, Generic), T>::type maxon::PrivateDefaultReturnValue ( NULL_RETURN_REASON  reason,
OverloadRank4   
)

◆ PrivateIncompleteNullReturnValue() [1/5]

MAXON_ATTRIBUTE_FORCE_INLINE T maxon::PrivateIncompleteNullReturnValue ( NULL_RETURN_REASON  reason,
OverloadRank0   
)

◆ PrivateIncompleteNullReturnValue() [2/5]

MAXON_ATTRIBUTE_FORCE_INLINE SFINAEHelper<T, typename DefaultValueFunctions<typename std::decay<T>::type>::Default>::type maxon::PrivateIncompleteNullReturnValue ( NULL_RETURN_REASON  reason,
OverloadRank1   
)

◆ PrivateIncompleteNullReturnValue() [3/5]

MAXON_ATTRIBUTE_FORCE_INLINE SFINAEHelper<T, typename DefaultValueFunctions<typename std::decay<T>::type>::ResultMarker>::type maxon::PrivateIncompleteNullReturnValue ( NULL_RETURN_REASON  reason,
OverloadRank2   
)

◆ PrivateIncompleteNullReturnValue() [4/5]

MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if<STD_IS_REPLACEMENT(same, Id, typename std::decay<T>::type), T>::type maxon::PrivateIncompleteNullReturnValue ( NULL_RETURN_REASON  reason,
OverloadRank3   
)

◆ PrivateIncompleteNullReturnValue() [5/5]

MAXON_ATTRIBUTE_FORCE_INLINE std::enable_if<IsZeroInitialized<typename std::decay<T>::type>::value, T>::type maxon::PrivateIncompleteNullReturnValue ( NULL_RETURN_REASON  reason,
OverloadRank4   
)

◆ operator%() [1/20]

void maxon::operator% ( const Result< Bool > &  res,
Result< Bool > &  yieldResult 
)

◆ operator%() [2/20]

void maxon::operator% ( const Result< void > &  res,
Result< Bool > &  yieldResult 
)

◆ MAXON_REGISTRY() [29/64]

maxon::MAXON_REGISTRY ( DescriptionProcessor  ,
DescriptionProcessors  ,
"net.maxon.registry.descriptionprocessors"   
)

◆ g_attributeInternedId()

const AttributeInternedId maxon::g_attributeInternedId ( HELPER::GetId().GetCString()  )

◆ MAXON_MEMBERTYPE_DETECTOR() [2/4]

maxon::MAXON_MEMBERTYPE_DETECTOR ( IsFidClass  ,
FidType  ,
std::false_type   
)

◆ ConvertKeyToDataPtr() [1/2]

std::enable_if<!IsFidClass<KEY>::value, typename std::conditional<STD_IS_REPLACEMENT(reference, KEY) || STD_IS_REPLACEMENT(const, KEY), ConstDataPtr, MoveDataPtr>::type>::type maxon::ConvertKeyToDataPtr ( KEY &&  key)

The ConvertKeyToDataPtr helper functions are used for functions which need to separate an template argument T&& between d FId<T, KEYTYPE> and a real datatype. e.g. DataDictionary::Get accepts 2 versions, one thing is the key itself, the other is FId with the keytype and the datatype. the implementation is now easy.

class X
{
DataDictionary _dict;
public:
template <typename T, typename KEY> void Set(KEY&& key, T&& data)
{
_dict.SetData(ConvertKeyToDataPtr<DataPtr, typename std::decay<T>::type>(std::forward<KEY>(key)), Data(std::forward<T>(data)));
}
template <typename T = void, typename KEY> typename std::conditional<STD_IS_REPLACEMENT(void, T), typename IsFidClass<KEY>::type, T>::type Get(KEY&& key)
{
using TT = typename std::conditional<STD_IS_REPLACEMENT(void, T), typename IsFidClass<KEY>::type, T>::type;
_dict.GetData(ConvertKeyToDataPtr<ConstDataPtr, TT>(std::forward<KEY>(key)));
return TT();
}
};
#define Set(a0, a1, a2, a3, a4, a5)
Definition: Python-ast.h:586
PyObject * key
Definition: abstract.h:289
#define STD_IS_REPLACEMENT(name,...)
Definition: compilerdetection.h:292
const Class< R > & Get(const Id &cls)
Definition: objectbase.h:2073
std::enable_if<!IsFidClass< KEY >::value, typename std::conditional< STD_IS_REPLACEMENT(reference, KEY)||STD_IS_REPLACEMENT(const, KEY), ConstDataPtr, MoveDataPtr >::type >::type ConvertKeyToDataPtr(KEY &&key)
Definition: fid.h:533

◆ ConvertKeyToDataPtr() [2/2]

std::enable_if<IsFidClass<KEY>::value, ConstDataPtr>::type maxon::ConvertKeyToDataPtr ( KEY &&  key)

◆ TestRestriction()

RESTRICT maxon::TestRestriction ( y,
OverloadRank0   
)

◆ MAXON_MEMBERTYPE_DETECTOR() [3/4]

maxon::MAXON_MEMBERTYPE_DETECTOR ( GetRestrict  ,
RESTRICT_DICTIONARY_PROPS  ,
maxon::RESTRICT   
)

◆ IsSourceControlAvailable()

Bool maxon::IsSourceControlAvailable ( )

Controls a source control system, e.g. Perforce.

Returns
true if if system is available

◆ MAXON_ENUM_FLAGS() [11/34]

enum maxon::FILEFORMATDETECTIONFLAGS maxon::MAXON_ENUM_FLAGS ( FILEFORMATDETECTIONFLAGS  )

◆ MAXON_REGISTRY() [30/64]

maxon::MAXON_REGISTRY ( FileFormat  ,
FileFormats  ,
"net.maxon.registry.fileformats"   
)

Registry to register/iterate all available FileFormat implementations.

◆ MAXON_DECLARATION() [33/89]

maxon::MAXON_DECLARATION ( Class< FileFormat >  ,
FileFormatBaseClass  ,
"net.maxon.class.fileformatbase"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

This class should be added to your own image fileformat implementation. It implements default values for GetData() for FILEFORMATPROPERTIES of files.

◆ MAXON_DECLARATION() [34/89]

maxon::MAXON_DECLARATION ( Class< FileFormatDetectionCacheRef >  ,
FileFormatDetectionCacheClass  ,
"net.maxon.class.fileformatdetectioncache"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ MAXON_ENUM_LIST() [35/113]

enum maxon::FILEFORMAT_PRIORITY maxon::MAXON_ENUM_LIST ( FILEFORMAT_PRIORITY  )

◆ operator+() [1/2]

FILEFORMAT_PRIORITY maxon::operator+ ( FILEFORMAT_PRIORITY  s1,
FILEFORMAT_PRIORITY  s2 
)

◆ operator-()

FILEFORMAT_PRIORITY maxon::operator- ( FILEFORMAT_PRIORITY  s1,
FILEFORMAT_PRIORITY  s2 
)

◆ MAXON_REGISTRY() [31/64]

maxon::MAXON_REGISTRY ( FileFormatHandler  ,
FileFormatHandlers  ,
"net.maxon.registry.fileformathandlers"   
)

Registry to register/iterate all available FileFormatHandler implementations.

◆ PrivateGetDataType() [7/19]

Result<DataType> maxon::PrivateGetDataType ( ForwardRef< T > **  ,
OverloadRank0   
)

◆ MAXON_DATATYPE() [33/73]

maxon::MAXON_DATATYPE ( HalfFloat  ,
"float16"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

◆ MAXON_DECLARATION() [35/89]

maxon::MAXON_DECLARATION ( Class< HierarchyObjectRef<>>  ,
HierarchyObjectClass  ,
"net.maxon.class.hierarchyobject"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ TraverseChildren() [1/2]

static Result<Bool> maxon::TraverseChildren ( const REFTYPE &  object,
const Delegate< Result< Bool >(const REFTYPE &object, const REFTYPE &parent, const ConstDataPtr &branchId, Int depth)> &  function,
const ConstDataPtr branchId = ConstDataPtr(),
Int  depth = Int(0) 
)
static

Helper function to traverse all children of the root object.

MediaStreamRef stream; // object with hierarchy to run through
BaseArray<MediaStreamRef> res;
TraverseChildren<MediaStreamRef>(stream,
[&res](const MediaStreamRef& child, const MediaStreamRef& parent, const ConstDataPtr& branch, Int depth) -> Result<Bool>
{
res.Append(child) iferr_return;
return true;
PyObject * stream
Definition: codecs.h:186
Parameters
[in]objectObject to iterate.
[in]functionFunction which is called for each object.
[in]branchIdThe branch.
[in]depthStart value for the depth level.
Returns
returns false if iteration should stop. otherwise true to continue.

◆ TraverseMeAndChildren() [1/2]

static Result<Bool> maxon::TraverseMeAndChildren ( const REFTYPE &  object,
const Delegate< Result< Bool >(const REFTYPE &object, const REFTYPE &parent, const ConstDataPtr &branchId, Int depth)> &  function,
const ConstDataPtr branchId = ConstDataPtr(),
Int  depth = Int(0) 
)
static

Helper function to traverse the given object with its children.

MediaStreamRef stream; // object with hierarchy to run through
BaseArray<MediaStreamRef> res;
TraverseMeAndChildren<MediaStreamRef>(stream,
[&res](const MediaStreamRef& child, const MediaStreamRef& parent, const ConstDataPtr& branch, Int depth) -> Result<Bool>
{
res.Append(child) iferr_return;
return true;
Parameters
[in]objectObject to iterate.
[in]functionFunction which is called for each object.
[in]branchIdThe branch.
[in]depthStart value for the depth level.
Returns
returns false if iteration should stop. otherwise true to continue.

◆ TraverseChildren() [2/2]

static Result<Bool> maxon::TraverseChildren ( const REFTYPE &  t,
const ConstDataPtr branch,
const Delegate< Result< Bool >(const REFTYPE &child, const REFTYPE &parent, const ConstDataPtr &branch, Int depth)> &  func,
Int  depth 
)
static

Helper function to traverse all children of the root object t.

MediaStreamRef stream; // object with hierarchy to run through
BaseArray<MediaStreamRef> res;
TraverseChildren<MediaStreamRef>(stream, ConstDataPtr(),
[&res](const MediaStreamRef& child, const MediaStreamRef& parent, const ConstDataPtr& branch, Int depth) -> Result<Bool>
{
res.Append(child) iferr_return;
return true;
}, 0) iferr_return;
Parameters
[in]tobject to iterate.
[in]funcfunction which is called for each object.
Returns
returns false if iteration should stop. otherwise true to continue.

◆ TraverseMeAndChildren() [2/2]

static Result<Bool> maxon::TraverseMeAndChildren ( const REFTYPE &  t,
const REFTYPE &  parent,
const ConstDataPtr branch,
const Delegate< Result< Bool >(const REFTYPE &child, const REFTYPE &parent, const ConstDataPtr &branch, Int depth)> &  func,
Int  depth = 0 
)
static

Helper function to traverse all children of the root object t, but also the given object.

MediaStreamRef stream; // object with hierarchy to run through
BaseArray<MediaStreamRef> res;
TraverseMeAndChildren<MediaStreamRef>(stream, MediaStreamRef(), ConstDataPtr(),
[&res](const MediaStreamRef& child, const MediaStreamRef& parent, const ConstDataPtr& branch, Int depth) -> Result<Bool>
{
res.Append(child) iferr_return;
return true;
Parameters
[in]tobject to iterate.
[in]funcfunction which is called for each object.
Returns
returns false if iteration should stop. otherwise true to continue.

◆ MAXON_ENUM_LIST() [36/113]

enum maxon::ASSET_UPDATE_POLICY maxon::MAXON_ENUM_LIST ( ASSET_UPDATE_POLICY  ,
"net.maxon.datatype.enum.asset_update_policy"   
)

◆ PrivateGetDataType() [8/19]

Result<DataType> maxon::PrivateGetDataType ( IntersectionType< T... > **  ,
OverloadRank0   
)

◆ PrivateGetDataType() [9/19]

Result<DataType> maxon::PrivateGetDataType ( UnionType< T... > **  ,
OverloadRank0   
)

◆ MAXON_ENUM_LIST() [37/113]

enum maxon::IOTIMEMODE maxon::MAXON_ENUM_LIST ( IOTIMEMODE  ,
"net.maxon.datatype.enum.iotimemode"   
)

◆ MAXON_ENUM_LIST() [38/113]

enum maxon::URLCOMPARE maxon::MAXON_ENUM_LIST ( URLCOMPARE  ,
"net.maxon.datatype.enum.urlcompare"   
)

◆ MAXON_ENUM_LIST() [39/113]

enum maxon::IODETECT maxon::MAXON_ENUM_LIST ( IODETECT  ,
"net.maxon.datatype.enum.iodetect"   
)

◆ MAXON_ENUM_FLAGS() [12/34]

enum maxon::OPENSTREAMFLAGS maxon::MAXON_ENUM_FLAGS ( OPENSTREAMFLAGS  ,
"net.maxon.datatype.enum.openstreamflags"   
)

◆ MAXON_ENUM_FLAGS() [13/34]

enum maxon::NORMALIZEFLAGS maxon::MAXON_ENUM_FLAGS ( NORMALIZEFLAGS  ,
"net.maxon.datatype.enum.normalizeflags"   
)

◆ MAXON_ENUM_FLAGS() [14/34]

enum maxon::IOATTRIBUTES UInt maxon::MAXON_ENUM_FLAGS ( IOATTRIBUTES  ,
"net.maxon.datatype.enum.ioattributes"   
)

◆ ConvertIoAttributes()

void maxon::ConvertIoAttributes ( IOATTRIBUTES attributes)

Converts an IOATTRIBUTES value between different operating systems. If there is no RWX bit set the R attribute will be set in Linux and OSX. The W bit is set if the read-only bit is not set. On Windows the read-only bit is set if at least one RWX bit is set and no W bit is set.

Parameters
[in,out]attributesAttributes to convert.

◆ MAXON_ENUM_FLAGS() [15/34]

enum maxon::IOSHOWINOSFLAGS maxon::MAXON_ENUM_FLAGS ( IOSHOWINOSFLAGS  ,
"net.maxon.datatype.enum.ioshowinosflags"   
)

◆ CreateMemoryFileWithSuffix()

Result<Url> maxon::CreateMemoryFileWithSuffix ( const String suffix = String())

CreateMemoryFileWithSuffix returns a url of a memory file to write into.

Parameters
[in]suffixOptional suffix for the memory file.
Returns
Url on success. this url can be used to write to.

◆ PrivateConsoleOutput()

Result<void> maxon::PrivateConsoleOutput ( const String str,
const SourceLocation loc,
WRITEMETA  level 
)

◆ MAXON_ENUM_FLAGS() [16/34]

enum maxon::MACHINESTATE maxon::MAXON_ENUM_FLAGS ( MACHINESTATE  )

◆ MAXON_DECLARATION() [36/89]

maxon::MAXON_DECLARATION ( Class< MachineRef >  ,
LocalMachineClass  ,
"net.maxon.class.localmachine"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ MAXON_DATATYPE() [34/73]

maxon::MAXON_DATATYPE ( CreateObjectRefFunc  ,
"net.maxon.datatype.createobjectreffunc"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ MAXON_REGISTRY() [32/64]

maxon::MAXON_REGISTRY ( CreateObjectRefFunc  ,
MachineImplementationFactories  ,
"net.maxon.registry.machineimplementationfactories"   
)

◆ MAXON_IMPLEMENTATION_SIMPLE_REGISTER() [2/5]

maxon::MAXON_IMPLEMENTATION_SIMPLE_REGISTER ( MapImpl< MAP >  )

◆ ToMapPtr()

const MapInterface<K, V>* maxon::ToMapPtr ( const MapInterface< K, V > &  map)

Returns a pointer to the map reference argument. This function is useful if you have to convert some map to a pointer to a MapInterface:

void Func(const MapInterface<Int, const String>* map);
HashMap<Int, String> myMap;
Func(ToMapPtr(myMap));
const MapInterface< K, V > * ToMapPtr(const MapInterface< K, V > &map)
Definition: map.h:923

For WritableMapInterface parameters, use ToWritableMapPtr instead.

See also
MapInterface.
Template Parameters
KType of keys of the map, this is deduced by the compiler.
VType of values of the map, this is deduced by the compiler.
Note
If the argument is a temporary (which usually is the case), the result will be a pointer to a temporary. Make sure that the pointer is used only within the lifetime of the temporary. For the above example, it suffices that Func uses the map only during its execution.

◆ ToWritableMapPtr()

WritableMapInterface<K, V>* maxon::ToWritableMapPtr ( WritableMapInterface< K, V > &  map)

Returns a pointer to the map reference argument. This function is useful if you have to convert some map to a pointer to a MapInterface:

void Func(WritableMapInterface<Int, String>* map);
HashMap<Int, String> myMap;
Func(ToWritableMapPtr(myMap));
WritableMapInterface< K, V > * ToWritableMapPtr(WritableMapInterface< K, V > &map)
Definition: map.h:949

For non-modifiable map parameters, use ToMapPtr instead.

See also
MapInterface.
Template Parameters
KType of keys of the map, this is deduced by the compiler.
VType of values of the map, this is deduced by the compiler.
Note
If the argument is a temporary (which usually is the case), the result will be a pointer to a temporary. Make sure that the pointer is used only within the lifetime of the temporary. For the above example, it suffices that Func uses the map only during its execution.

◆ operator*() [1/5]

Col3<typename MultiplicativePromotion<T, S, STD_IS_REPLACEMENT(scalar, S)>::type, 1> maxon::operator* ( s,
const Col3< T, STR > &  v 
)

Multiplies each vector component by a scalar.

◆ PrivateGetDataType() [10/19]

Result<DataType> maxon::PrivateGetDataType ( Col3< T, 1 > **  ,
OverloadRank1   
)

◆ operator*() [2/5]

Col4<typename MultiplicativePromotion<T, S, STD_IS_REPLACEMENT(scalar, S)>::type, 1> maxon::operator* ( s,
const Col4< T, STR > &  v 
)

Multiplies each vector component by a scalar.

◆ PrivateGetDataType() [11/19]

Result<DataType> maxon::PrivateGetDataType ( Col4< T, 1 > **  ,
OverloadRank1   
)

◆ operator*() [3/5]

Vec3<typename MultiplicativePromotion<T, S, STD_IS_REPLACEMENT(scalar, S)>::type, 1> maxon::operator* ( s,
const Vec3< T, STR > &  v 
)

Multiplies each vector component by a scalar.

◆ PrivateGetDataType() [12/19]

Result<DataType> maxon::PrivateGetDataType ( Vec3< T, 1 > **  ,
OverloadRank1   
)

◆ operator*() [4/5]

Vec2<typename MultiplicativePromotion<T, S, STD_IS_REPLACEMENT(scalar, S)>::type, 1, SPACE> maxon::operator* ( s,
const Vec2< T, STR, SPACE > &  v 
)

Multiplies each vector component by a scalar.

◆ PrivateGetDataType() [13/19]

Result<DataType> maxon::PrivateGetDataType ( Vec2< T, 1, SPACE > **  ,
OverloadRank1   
)

◆ operator*() [5/5]

Vec4<typename MultiplicativePromotion<T, S, STD_IS_REPLACEMENT(scalar, S)>::type, 1> maxon::operator* ( s,
const Vec4< T, STR > &  v 
)

Multiplies each vector component by a scalar.

◆ PrivateGetDataType() [14/19]

Result<DataType> maxon::PrivateGetDataType ( Vec4< T, 1 > **  ,
OverloadRank1   
)

◆ PrivateGetDataType() [15/19]

Result<DataType> maxon::PrivateGetDataType ( SqrMat3< T > **  ,
OverloadRank1   
)

◆ PrivateGetDataType() [16/19]

Result<DataType> maxon::PrivateGetDataType ( Mat3< T > **  ,
OverloadRank1   
)

◆ PrivateGetDataType() [17/19]

Result<DataType> maxon::PrivateGetDataType ( SqrMat2< T > **  ,
OverloadRank1   
)

◆ PrivateGetDataType() [18/19]

Result<DataType> maxon::PrivateGetDataType ( Mat2< T > **  ,
OverloadRank1   
)

◆ PrivateGetDataType() [19/19]

Result<DataType> maxon::PrivateGetDataType ( SqrMat4< T > **  ,
OverloadRank1   
)

◆ MAXON_REGISTRY() [33/64]

maxon::MAXON_REGISTRY ( DataDictionary  ,
ModuleVersionInfos  ,
"net.maxon.registry.moduleversioninfos"   
)

◆ MAXON_REGISTRY() [34/64]

maxon::MAXON_REGISTRY ( Id  ,
ReplaceModule  ,
"net.maxon.registry.replacemodule"   
)

ReplaceModule registry allows to renamed dlls/modules.

If a module is renamed compared to previous releases this extension point keep record of those changes. For example the "zip" module was renamed to "zipio". So the new "zipio" module will register the zip module as replacement using this macro MAXON_REPLACE_MODULE("net.maxon.c4d.zip"); Please note that you have register the previous Id returned by PRIVATE_MAXON_MODULE.GetBase().GetId(). It's possible to register multiple replacements.

◆ MAXON_DECLARATION() [37/89]

maxon::MAXON_DECLARATION ( ComponentDescriptor  ,
ObservableCombinerRunAllComponent  ,
"net.maxon.component.observablecombinerrunall"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

Implementation of CombinerInterface. Using this combiner ensures that all subscribers are called. The result of the last notification will be returned.

◆ MAXON_DECLARATION() [38/89]

maxon::MAXON_DECLARATION ( ComponentDescriptor  ,
ObservableCombinerRunAllBoolOrComponent  ,
"net.maxon.component.observablecombinerrunallboolor"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

Implementation of CombinerInterface. Using this combiner ensures that all subscribers are called. The result is combined by an OR operation.

◆ MAXON_DECLARATION() [39/89]

maxon::MAXON_DECLARATION ( ComponentDescriptor  ,
ObservableCombinerRunAllBoolUntilFalse  ,
"net.maxon.component.observablecombinerrunallbooluntilfalse"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

Implementation of CombinerInterface. The result is initialized with true and runs until the first false occurs.

◆ MAXON_DECLARATION() [40/89]

maxon::MAXON_DECLARATION ( ComponentDescriptor  ,
ObservableCombinerRunAllBoolUntilTrue  ,
"net.maxon.component.observablecombinerrunallbooluntiltrue"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

Implementation of CombinerInterface. The result is initialized with false and runs until the first true occurs.

◆ MAXON_DECLARATION() [41/89]

maxon::MAXON_DECLARATION ( ComponentDescriptor  ,
ObservableCombinerRunAllEnumFlagsOrComponent  ,
"net.maxon.component.observablecombinerrunallenumflagsor"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

Implementation of CombinerInterface. Using this combiner ensures that all subscribers are called. The result is combined by an OR operation.

◆ MAXON_DECLARATION() [42/89]

maxon::MAXON_DECLARATION ( ComponentDescriptor  ,
ObservableCombinerRunAllEnumFlags64OrComponent  ,
"net.maxon.component.observablecombinerrunallenumflags64or"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

Implementation of CombinerInterface. Using this combiner ensures that all subscribers are called. The result is combined by an OR operation. Use this for 64-bit-wide enums.

◆ MAXON_DECLARATION() [43/89]

maxon::MAXON_DECLARATION ( ComponentDescriptor  ,
ObservableCombinerRunAllAggregateErrorsComponent  ,
"net.maxon.component.observablecombinerrunallaggregateerrors"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

Implementation of CombinerInterface. Using this combiner ensures that all subscribers are called. All errors returned by the subscribers will be aggregated and returnd as AggregatedError.

◆ MAXON_DECLARATION() [44/89]

maxon::MAXON_DECLARATION ( Class< FunctionBaseRef >  ,
FunctionBaseClass  ,
"net.maxon.class.functionbase"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ MAXON_DECLARATION() [45/89]

maxon::MAXON_DECLARATION ( Class< ObservableBaseRef >  ,
ObservableClass  ,
"net.maxon.class.observable"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ MAXON_DECLARATION() [46/89]

maxon::MAXON_DECLARATION ( Class< ObserverObjectRef >  ,
ObserverObjectClass  ,
"net.maxon.class.observerobject"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ MAXON_ENUM_LIST() [40/113]

enum maxon::NO_VALUE_TYPE maxon::MAXON_ENUM_LIST ( NO_VALUE_TYPE  )

◆ operator==() [2/8]

Bool maxon::operator== ( const Opt< T > &  lhs,
const Opt< T > &  rhs 
)

Returns true if both Opts have the same value or both have no value.

◆ operator==() [3/8]

Bool maxon::operator== ( const Opt< T > &  opt,
NO_VALUE_TYPE   
)

Returns true, if Opt contains no value.

◆ operator==() [4/8]

Bool maxon::operator== ( NO_VALUE_TYPE  ,
const Opt< T > &  opt 
)

◆ operator!=() [2/7]

Bool maxon::operator!= ( const Opt< T > &  opt,
NO_VALUE_TYPE   
)

Returns true, if Opt contains a value.

◆ operator!=() [3/7]

Bool maxon::operator!= ( NO_VALUE_TYPE  ,
const Opt< T > &  opt 
)

◆ MAXON_REGISTRY() [35/64]

maxon::MAXON_REGISTRY ( ParametricType  ,
ParametricTypes  ,
"net.maxon.registry.parametrictypes"   
)

◆ MAXON_ENUM_FLAGS() [17/34]

enum maxon::PARSERFLAGS maxon::MAXON_ENUM_FLAGS ( PARSERFLAGS  )

◆ MAXON_REGISTRY() [36/64]

maxon::MAXON_REGISTRY ( Class< ParserRef >  ,
ParserClasses  ,
"net.maxon.interface.registry.parserclasses"   
)

◆ MAXON_DECLARATION() [47/89]

maxon::MAXON_DECLARATION ( Class< ParserRef >  ,
ParserBaseClass  ,
"net.maxon.interface.parserclass.base"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ atomic_try_cas32()

MAXON_ATTRIBUTE_FORCE_INLINE Bool maxon::atomic_try_cas32 ( Int32 volatile *  dst,
Int32  xchg,
Int32  cmp 
)

Atomic Compare And Swap: Exchange memory location content with new value if its equal to comparison value This function implicitly creates a memory barrier.

Parameters
[in,out]dstMemory location.
[in]xchgNew value.
[in]cmpComparison value.
Returns
True if successul, false if memory location wasn't changed.

◆ atomic_try_cas32HLE()

MAXON_ATTRIBUTE_FORCE_INLINE Bool maxon::atomic_try_cas32HLE ( Int32 volatile *  dst,
Int32  xchg,
Int32  cmp 
)

◆ atomic_swap_add8()

MAXON_ATTRIBUTE_FORCE_INLINE Char maxon::atomic_swap_add8 ( Char volatile *  dst,
Char  value 
)

Atomic Add: Add value to memory location content and return the previous value This function implicitly creates a memory barrier.

Parameters
[in,out]dstMemory location.
[in]valueValue to add.
Returns
Previous memory location content.

◆ atomic_swap_add16()

MAXON_ATTRIBUTE_FORCE_INLINE Int16 maxon::atomic_swap_add16 ( Int16 volatile *  dst,
Int16  value 
)

Atomic Add: Add value to memory location content and return the previous value This function implicitly creates a memory barrier.

Parameters
[in,out]dstMemory location.
[in]valueValue to add.
Returns
Previous memory location content.

◆ atomic_swap_add32()

MAXON_ATTRIBUTE_FORCE_INLINE Int32 maxon::atomic_swap_add32 ( Int32 volatile *  dst,
Int32  value 
)

Atomic Add: Add value to memory location content and return the previous value This function implicitly creates a memory barrier.

Parameters
[in,out]dstMemory location.
[in]valueValue to add.
Returns
Previous memory location content.

◆ atomic_swap8()

MAXON_ATTRIBUTE_FORCE_INLINE Char maxon::atomic_swap8 ( Char volatile *  dst,
Char  value 
)

Atomic Swap: Store a value and return the memory location's previous value This function implicitely creates a memory barrier.

Parameters
[in,out]dstMemory location.
[in]valueNew value.
Returns
Previous memory location content.

◆ atomic_swap16()

MAXON_ATTRIBUTE_FORCE_INLINE Int16 maxon::atomic_swap16 ( Int16 volatile *  dst,
Int16  value 
)

Atomic Swap: Store a value and return the memory location's previous value This function implicitely creates a memory barrier.

Parameters
[in,out]dstMemory location.
[in]valueNew value.
Returns
Previous memory location content.

◆ atomic_swap32()

MAXON_ATTRIBUTE_FORCE_INLINE Int32 maxon::atomic_swap32 ( Int32 volatile *  dst,
Int32  value 
)

Atomic Swap: Store a value and return the memory location's previous value This function implicitely creates a memory barrier.

Parameters
[in,out]dstMemory location.
[in]valueNew value.
Returns
Previous memory location content.

◆ atomic_try_cas64()

MAXON_ATTRIBUTE_FORCE_INLINE Bool maxon::atomic_try_cas64 ( Int64 volatile *  dst,
Int64  xchg,
Int64  cmp 
)

Atomic Compare And Swap: Exchange memory location content with new value if its equal to comparision value This function implicitely creates a memory barrier.

Parameters
[in,out]dstMemory location.
[in]xchgNew value.
[in]cmpComparison value.
Returns
True if successul, false if memory location wasn't changed.

◆ atomic_try_cas64HLE()

MAXON_ATTRIBUTE_FORCE_INLINE Bool maxon::atomic_try_cas64HLE ( Int64 volatile *  dst,
Int64  xchg,
Int64  cmp 
)

◆ atomic_try_cas128()

MAXON_ATTRIBUTE_FORCE_INLINE Bool maxon::atomic_try_cas128 ( Int64 volatile *  dst,
Int64  xchghi,
Int64  xchglo,
Int64  cmphi,
Int64  cmplo 
)

Atomic Compare And Swap: Exchange memory location content with new value if its equal to comparision value This function implicitely creates a memory barrier.

Parameters
[in,out]dstMemory location.
[in]xchghiUpper 64 bit of the new value.
[in]xchgloLower 64 bit of the new value.
[in]cmphiUpper 64 bit of the comparison value.
[in]cmploLower 64 bit of the comparison value.
Returns
True if successul, false if memory location wasn't changed.

◆ atomic_swap_add64()

MAXON_ATTRIBUTE_FORCE_INLINE Int64 maxon::atomic_swap_add64 ( Int64 volatile *  dst,
Int64  value 
)

Atomic Add: Add value to memory location content and return the previous value This function implicitly creates a memory barrier.

Parameters
[in,out]dstMemory location.
[in]valueValue to add.
Returns
Previous memory location content.

◆ atomic_swap64()

MAXON_ATTRIBUTE_FORCE_INLINE Int64 maxon::atomic_swap64 ( Int64 volatile *  dst,
Int64  value 
)

Atomic Swap: Store a value and return the memory location's previous value This function implicitly creates a memory barrier.

Parameters
[in,out]dstMemory location.
[in]valueNew value.
Returns
Previous memory location content.

◆ atomic_swap_or32()

MAXON_ATTRIBUTE_FORCE_INLINE Int32 maxon::atomic_swap_or32 ( Int32 volatile *  dst,
Int32  mask 
)

Atomic Or: Or value to memory location content and return the previous value This function implicitely creates a memory barrier.

Parameters
[in,out]dstMemory location.
[in]maskMask for bitwise or.
Returns
Previous memory location content.

◆ atomic_swap_and32()

MAXON_ATTRIBUTE_FORCE_INLINE Int32 maxon::atomic_swap_and32 ( Int32 volatile *  dst,
Int32  mask 
)

Atomic And: And value to memory location content and return the previous value This function implicitely creates a memory barrier.

Parameters
[in,out]dstMemory location.
[in]maskMask for bitwise and.
Returns
Previous memory location content.

◆ atomic_try_cas8()

MAXON_ATTRIBUTE_FORCE_INLINE Bool maxon::atomic_try_cas8 ( Char volatile *  dst,
Char  xchg,
Char  cmp 
)

Atomic Compare And Swap: Exchange memory location content with new value if its equal to comparison value This function implicitly creates a memory barrier.

Parameters
[in,out]dstMemory location.
[in]xchgNew value.
[in]cmpComparison value.
Returns
True if successul, false if memory location wasn't changed.

◆ atomic_try_cas16()

MAXON_ATTRIBUTE_FORCE_INLINE Bool maxon::atomic_try_cas16 ( Int16 volatile *  dst,
Int16  xchg,
Int16  cmp 
)

Atomic Compare And Swap: Exchange memory location content with new value if its equal to comparison value This function implicitly creates a memory barrier.

Parameters
[in,out]dstMemory location.
[in]xchgNew value.
[in]cmpComparison value.
Returns
True if successul, false if memory location wasn't changed.

◆ atomic_consume_load8()

MAXON_ATTRIBUTE_FORCE_INLINE Char maxon::atomic_consume_load8 ( Char volatile *  src)

Atomic load with consume memory order. If another thread has released a store on this location it is guaranteed that after a load with consume memory order that reads the value stored direct dependencies are synchronized (e.g. if the value is a pointer to a structure you can safely access the elements of the structure that have been written before the release). This means that unrelated loads following this method might be reordered by the compiler or the CPU and can be executed before it. For most cpu architectures this the same instruction as an ordinary load which implies no performance penalty compared to a load with relaxed memory order.

Parameters
[in]srcMemory location.
Returns
Read memory location content.

◆ atomic_consume_load16()

MAXON_ATTRIBUTE_FORCE_INLINE Int16 maxon::atomic_consume_load16 ( Int16 volatile *  src)

Atomic load with consume memory order. If another thread has released a store on this location it is guaranteed that after a load with consume memory order that reads the value stored direct dependencies are synchronized (e.g. if the value is a pointer to a structure you can safely access the elements of the structure that have been written before the release). This means that unrelated loads following this method might be reordered by the compiler or the CPU and can be executed before it. For most cpu architectures this the same instruction as an ordinary load which implies no performance penalty compared to a load with relaxed memory order.

Parameters
[in]srcMemory location.
Returns
Read memory location content.

◆ atomic_consume_load32()

MAXON_ATTRIBUTE_FORCE_INLINE Int32 maxon::atomic_consume_load32 ( Int32 volatile *  src)

Atomic load with consume memory order. If another thread has released a store on this location it is guaranteed that after a load with consume memory order that reads the value stored direct dependencies are synchronized (e.g. if the value is a pointer to a structure you can safely access the elements of the structure that have been written before the release). This means that unrelated loads following this method might be reordered by the compiler or the CPU and can be executed before it. For most cpu architectures this the same instruction as an ordinary load which implies no performance penalty compared to a load with relaxed memory order.

Parameters
[in]srcMemory location.
Returns
Read memory location content.

◆ atomic_consume_load64()

MAXON_ATTRIBUTE_FORCE_INLINE Int64 maxon::atomic_consume_load64 ( Int64 volatile *  src)

Atomic load with consume memory order. If another thread has released a store on this location it is guaranteed that after a load with consume memory order that reads the value stored direct dependencies are synchronized (e.g. if the value is a pointer to a structure you can safely access the elements of the structure that have been written before the release). This means that unrelated loads following this method might be reordered by the compiler or the CPU and can be executed before it. For most cpu architectures this the same instruction as an ordinary load which implies no performance penalty compared to a load with relaxed memory order.

Parameters
[in]srcMemory location.
Returns
Read memory location content.

◆ atomic_acquire_load8()

MAXON_ATTRIBUTE_FORCE_INLINE Char maxon::atomic_acquire_load8 ( Char volatile *  src)

Atomic load with acquire memory order. If another thread has released a store on this location it is guaranteed that after a load with acquire memory order all following loads will see the (relaxed) stores that preceeding the release. Furthermore subsequent loads or stores will not be speculatively executed before this load.

Parameters
[in]srcMemory location.
Returns
Read memory location content.

◆ atomic_acquire_load16()

MAXON_ATTRIBUTE_FORCE_INLINE Int16 maxon::atomic_acquire_load16 ( Int16 volatile *  src)

Atomic load with acquire memory order. If another thread has released a store on this location it is guaranteed that after a load with acquire memory order all following loads will see the (relaxed) stores that preceeding the release. Furthermore subsequent loads or stores will not be speculatively executed before this load.

Parameters
[in]srcMemory location.
Returns
Read memory location content.

◆ atomic_acquire_load32()

MAXON_ATTRIBUTE_FORCE_INLINE Int32 maxon::atomic_acquire_load32 ( Int32 volatile *  src)

Atomic load with acquire memory order. If another thread has released a store on this location it is guaranteed that after a load with acquire memory order all following loads will see the (relaxed) stores that preceeding the release. Furthermore subsequent loads or stores will not be speculatively executed before this load.

Parameters
[in]srcMemory location.
Returns
Read memory location content.

◆ atomic_acquire_load64()

MAXON_ATTRIBUTE_FORCE_INLINE Int64 maxon::atomic_acquire_load64 ( Int64 volatile *  src)

Atomic load with acquire memory order. If another thread has released a store on this location it is guaranteed that after a load with acquire memory order all following loads will see the (relaxed) stores that preceeding the release. Furthermore subsequent loads or stores will not be speculatively executed before this load.

Parameters
[in]srcMemory location.
Returns
Read memory location content.

◆ atomic_sequential_load8()

MAXON_ATTRIBUTE_FORCE_INLINE Char maxon::atomic_sequential_load8 ( Char volatile *  src)

Atomic load with sequentially consistent memory order.

Parameters
[in]srcMemory location.
Returns
Read memory location content.

◆ atomic_sequential_load16()

MAXON_ATTRIBUTE_FORCE_INLINE Int16 maxon::atomic_sequential_load16 ( Int16 volatile *  src)

Atomic load with sequentially consistent memory order.

Parameters
[in]srcMemory location.
Returns
Read memory location content.

◆ atomic_sequential_load32()

MAXON_ATTRIBUTE_FORCE_INLINE Int32 maxon::atomic_sequential_load32 ( Int32 volatile *  src)

Atomic load with sequentially consistent memory order.

Parameters
[in]srcMemory location.
Returns
Read memory location content.

◆ atomic_sequential_load64()

MAXON_ATTRIBUTE_FORCE_INLINE Int64 maxon::atomic_sequential_load64 ( Int64 volatile *  src)

Atomic load with sequentially consistent memory order.

Parameters
[in]srcMemory location.
Returns
Read memory location content.

◆ atomic_release_store8()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::atomic_release_store8 ( Char volatile *  dst,
Char  value 
)

Atomic store with release memory order. As soon as another thread reads on this location and obtains the stored value it is guaranteed that all prior (relaxed) stores are visible to it.

Parameters
[in]dstMemory location.
[in]valueValue to be stored.

◆ atomic_release_store16()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::atomic_release_store16 ( Int16 volatile *  dst,
Int16  value 
)

Atomic store with release memory order. As soon as another thread reads on this location and obtains the stored value it is guaranteed that all prior (relaxed) stores are visible to it.

Parameters
[in]dstMemory location.
[in]valueValue to be stored.

◆ atomic_release_store32()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::atomic_release_store32 ( Int32 volatile *  dst,
Int32  value 
)

Atomic store with release memory order. As soon as another thread reads on this location and obtains the stored value it is guaranteed that all prior (relaxed) stores are visible to it.

Parameters
[in]dstMemory location.
[in]valueValue to be stored.

◆ atomic_release_store32HLE()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::atomic_release_store32HLE ( Int32 volatile *  dst,
Int32  value 
)

◆ atomic_release_store64()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::atomic_release_store64 ( Int64 volatile *  dst,
Int64  value 
)

Atomic store with release memory order. As soon as another thread reads on this location and obtains the stored value it is guaranteed that all prior (relaxed) stores are visible to it.

Parameters
[in]dstMemory location.
[in]valueValue to be stored.

◆ atomic_release_store64HLE()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::atomic_release_store64HLE ( Int64 volatile *  dst,
Int64  value 
)

◆ atomic_sequential_store8()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::atomic_sequential_store8 ( Char volatile *  dst,
Char  value 
)

Atomic store with sequentially consistent memory order.

Parameters
[in]dstMemory location.
[in]valueValue to be stored.

◆ atomic_sequential_store16()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::atomic_sequential_store16 ( Int16 volatile *  dst,
Int16  value 
)

Atomic store with sequentially consistent memory order.

Parameters
[in]dstMemory location.
[in]valueValue to be stored.

◆ atomic_sequential_store32()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::atomic_sequential_store32 ( Int32 volatile *  dst,
Int32  value 
)

Atomic store with sequentially consistent memory order.

Parameters
[in]dstMemory location.
[in]valueValue to be stored.

◆ atomic_sequential_store64()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::atomic_sequential_store64 ( Int64 volatile *  dst,
Int64  value 
)

Atomic store with sequentially consistent memory order.

Parameters
[in]dstMemory location.
[in]valueValue to be stored.

◆ MAXON_DECLARATION() [48/89]

maxon::MAXON_DECLARATION ( Class< ProgressRef >  ,
ProgressObject  ,
"net.maxon.image.class.mediasessionprogressobject"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ MAXON_IMPLEMENTATION_SIMPLE_REGISTER() [3/5]

maxon::MAXON_IMPLEMENTATION_SIMPLE_REGISTER ( SetImpl< SET >  )

◆ ToSetPtr()

const SetInterface<T>* maxon::ToSetPtr ( const SetInterface< T > &  set)

Returns a pointer to the set reference argument. This function is useful if you have to convert some set to a pointer to a SetInterface:

void Func(const SetInterface<const Char>* set);
HashSet<Char> mySet;
Func(ToSetPtr(mySet));
const SetInterface< T > * ToSetPtr(const SetInterface< T > &set)
Definition: set.h:840

For WritableSetInterface parameters, use ToWritableSetPtr instead.

See also
SetInterface.
Template Parameters
TType of elements of the set, this is deduced by the compiler.
Note
If the argument is a temporary (which usually is the case), the result will be a pointer to a temporary. Make sure that the pointer is used only within the lifetime of the temporary. For the above example, it suffices that Func uses the set only during its execution.

◆ ToWritableSetPtr()

WritableSetInterface<T>* maxon::ToWritableSetPtr ( WritableSetInterface< T > &  set)

Returns a pointer to the set reference argument. This function is useful if you have to convert some set to a pointer to a SetInterface:

void Func(WritableSetInterface<const Char>* set);
HashSet<Char> mySet;
Func(ToWritableSetPtr(mySet));
WritableSetInterface< T > * ToWritableSetPtr(WritableSetInterface< T > &set)
Definition: set.h:865

For non-modifiable set parameters, use ToSetPtr instead.

See also
SetInterface.
Template Parameters
TType of elements of the set, this is deduced by the compiler.
Note
If the argument is a temporary (which usually is the case), the result will be a pointer to a temporary. Make sure that the pointer is used only within the lifetime of the temporary. For the above example, it suffices that Func uses the set only during its execution.

◆ MAXON_ENUM_LIST() [41/113]

enum maxon::ACCESSLEVEL maxon::MAXON_ENUM_LIST ( ACCESSLEVEL  )

◆ DetermineByteDigit()

Int32 maxon::DetermineByteDigit ( Int32  stage,
num,
GETINT &&  getInt 
)

◆ Compare()

Bool maxon::Compare ( const T &  x,
const T &  y,
GETINT &&  getInt 
)

◆ InsertSort()

void maxon::InsertSort ( Block< T >  data,
Int32  start,
Int32  end,
GETINT &&  getInt 
)

◆ ParadisByte()

MAXON_ATTRIBUTE_NO_INLINE Result<void> maxon::ParadisByte ( Int32  start,
Int32  target,
Block< T >  data,
GETINT &&  getInt,
JobQueueRef jobQueue,
Int32  processes = 1 
)

◆ Paradis()

Result<void> maxon::Paradis ( const Block< T > &  data,
UInt32  threadNum,
GETINT &&  getInt 
)

Parallel inplace Radix implementation to sort lists based on integers

To use this templated class a block of the data to sort has to be passed together with a lambda or delegate that defines how to extract an integer type from the underlying element type.

Example usage: class MyType { Int32 intType = 0; } BaseArray<MyType> myData // fill myData with data Block<MyType> myDataBlock {myData.GetFirst(), myData.GetCount()}; Paradis(myDataBlock, 16, [](const MyType& entry)-> const Int32& { return entry.intType; });

It is recommended to only have positive values in the list, but it does support negative values. This will just require additional memory and is slower.

Parameters
[in]dataThe array of type T that should be sorted.
[in]threadNumThe amount of parallel threads to be used. Maximum is 16 for stack memory reasons.
[in]getIntA lambda or delegate that returns an int type and has const T& as parameter signature. const Int&/Int32&(const& T)
Returns
OK on success.

◆ LoadVector4f32() [1/8]

Vector4f32 maxon::LoadVector4f32 ( const Vector64 v,
Float64  w,
Bool  aligned 
)

◆ LoadVector4f32() [2/8]

Vector4f32 maxon::LoadVector4f32 ( const Vector32 v,
Float32  w,
Bool  aligned 
)

◆ LoadVector4f32() [3/8]

Vector4f32 maxon::LoadVector4f32 ( const Vector4d64 v,
Bool  aligned 
)

◆ LoadVector4f32() [4/8]

Vector4f32 maxon::LoadVector4f32 ( const Vector4d32 v,
Bool  aligned 
)

◆ LoadVector4f32() [5/8]

Vector4f32 maxon::LoadVector4f32 ( const Color64 v,
Float64  w,
Bool  aligned 
)

◆ LoadVector4f32() [6/8]

Vector4f32 maxon::LoadVector4f32 ( const Color32 v,
Float32  w,
Bool  aligned 
)

◆ LoadVector4f32() [7/8]

Vector4f32 maxon::LoadVector4f32 ( const ColorA64 v,
Bool  aligned 
)

◆ LoadVector4f32() [8/8]

Vector4f32 maxon::LoadVector4f32 ( const ColorA32 v,
Bool  aligned 
)

◆ _mm_crc32_u64()

UInt64 maxon::_mm_crc32_u64 ( UInt64  c,
UInt64  d 
)

This file defines the intrinsics that are not available from the compiler.

◆ _mm_crc32_u32()

unsigned int maxon::_mm_crc32_u32 ( UInt32  c,
UInt32  d 
)

◆ _mm_crc32_u16()

unsigned int maxon::_mm_crc32_u16 ( UInt32  c,
UInt16  d 
)

◆ _mm_crc32_u8()

unsigned int maxon::_mm_crc32_u8 ( UInt32  c,
UChar  d 
)

◆ CastToVector4f32()

MAXON_ATTRIBUTE_FORCE_INLINE Vector4f32 maxon::CastToVector4f32 ( const Vector4i32 a)

Casts a Vector4i32 to a Vector4f32 vector.

Returns
A Vector4f32 vector.

◆ ConvertToVector4f32() [1/3]

MAXON_ATTRIBUTE_FORCE_INLINE Vector4f32 maxon::ConvertToVector4f32 ( const Vector4i32 a)

Converts a Vector4i32 to a Vector4f32 vector.

Returns
A Vector4f32 vector.

◆ CastToVector4i32()

MAXON_ATTRIBUTE_FORCE_INLINE Vector4i32 maxon::CastToVector4i32 ( const Vector4f32 a)

Casts a Vector4f32 to a Vector4i32 vector.

Returns
A Vector4i32 vector.

◆ ConvertToVector4i32()

MAXON_ATTRIBUTE_FORCE_INLINE Vector4i32 maxon::ConvertToVector4i32 ( const Vector4f32 a)

Converts a Vector4f32 to a Vector4i32 vector.

Returns
A Vector4i32 vector.

◆ ConvertToVector4f32() [2/3]

MAXON_ATTRIBUTE_FORCE_INLINE Vector4f32 maxon::ConvertToVector4f32 ( const Vector2f64 a,
const Vector2f64 b 
)

Converts two Vector2f64 to a Vector4f32 vector.

Returns
A Vector4f32 vector.

◆ ConvertToVector4f32() [3/3]

MAXON_ATTRIBUTE_FORCE_INLINE Vector4f32 maxon::ConvertToVector4f32 ( const Vector2f64 a)

Converts one Vector2f64 to a Vector4f32 vector.

Returns
A Vector4f32 vector. The two lower values are the converted members from the source vector, the two upper values are zero.

◆ MAXON_REGISTRY() [37/64]

maxon::MAXON_REGISTRY ( StreamConversionFactory  ,
StreamConversions  ,
"net.maxon.registry.streamconversions"   
)

◆ MAXON_DATATYPE() [35/73]

maxon::MAXON_DATATYPE ( ConversionTestSet  ,
"net.maxon.datatype.conversiontestset"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ MAXON_REGISTRY() [38/64]

maxon::MAXON_REGISTRY ( Factory< BaseArray< DataDictionary >()>  ,
StreamConversionTests  ,
"net.maxon.registry.streamconversiontests"   
)

DataDictionary used STREAMCONVERSIONTEST to for the tests.

◆ AddConversionTestSettingT()

MAXON_ATTRIBUTE_FORCE_INLINE Result<void> maxon::AddConversionTestSettingT ( MAXON_SOURCE_LOCATION_DECLARATION  ,
BaseArray< DataDictionary > &  resultArray,
const Block< const ConversionTestSet > &  set,
const Block< const SRCTYPE > &  srcData,
const Block< const DSTTYPE > &  compareData,
Bool  forbidLargeTest = false 
)

Helper function to add crypto tests.

◆ AddConversionTestSetting() [1/4]

Result<void> maxon::AddConversionTestSetting ( const SLOC &  allocLocation,
BaseArray< DataDictionary > &  resultArray,
const Block< const ConversionTestSet > &  set,
const Block< const Char > &  srcData,
const Block< const Char > &  compareData,
Bool  forbidLargeTest = false 
)

◆ AddConversionTestSetting() [2/4]

Result<void> maxon::AddConversionTestSetting ( const SLOC &  allocLocation,
BaseArray< DataDictionary > &  resultArray,
const Block< const ConversionTestSet > &  set,
const Block< const Utf32Char > &  srcData,
const Block< const Char > &  compareData,
Bool  forbidLargeTest = false 
)

◆ AddConversionTestSetting() [3/4]

Result<void> maxon::AddConversionTestSetting ( const SLOC &  allocLocation,
BaseArray< DataDictionary > &  resultArray,
const Block< const ConversionTestSet > &  set,
const Block< const Char > &  srcData,
const Block< const Utf32Char > &  compareData,
Bool  forbidLargeTest = false 
)

◆ AddConversionTestSetting() [4/4]

Result<void> maxon::AddConversionTestSetting ( const SLOC &  allocLocation,
BaseArray< DataDictionary > &  resultArray,
const Block< const ConversionTestSet > &  set,
const Block< const Utf32Char > &  srcData,
const Block< const Utf32Char > &  compareData,
Bool  forbidLargeTest = false 
)

◆ ConvertStreamConversionRef()

Factory<TO(const DataDictionary&)>& maxon::ConvertStreamConversionRef ( FROM &  obj)

◆ MAXON_DECLARATION() [49/89]

maxon::MAXON_DECLARATION ( Class< StreamConversionRef >  ,
StreamConversionBaseClass  ,
"net.maxon.class.streamconversionbase"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ ToString() [1/2]

std::enable_if<STD_IS_REPLACEMENT(enum, T), String>::type maxon::ToString ( const T &  object,
const FormatStatement formatStatement,
Bool  checkDataType = true 
)

◆ MAXON_ENUM_FLAGS() [18/34]

enum maxon::EXECUTEPROGRAMFLAGS maxon::MAXON_ENUM_FLAGS ( EXECUTEPROGRAMFLAGS  )

◆ MAXON_ENUM_LIST() [42/113]

enum maxon::EXECUTEPROGRAMCALLBACK maxon::MAXON_ENUM_LIST ( EXECUTEPROGRAMCALLBACK  )

◆ MAXON_ENUM_LIST() [43/113]

enum maxon::WAIT_PROCESS_RESULT maxon::MAXON_ENUM_LIST ( WAIT_PROCESS_RESULT  )

◆ MAXON_DECLARATION() [50/89]

maxon::MAXON_DECLARATION ( Class< SystemProcessObjectRef >  ,
SystemProcessObjectClass  ,
"net.maxon.class.systemprocessobject"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ MAXON_ENUM_LIST() [44/113]

enum maxon::THREADPRIORITY Int16 maxon::MAXON_ENUM_LIST ( THREADPRIORITY  )

◆ MAXON_ENUM_FLAGS() [19/34]

enum maxon::WAITMODE maxon::MAXON_ENUM_FLAGS ( WAITMODE  )

◆ MAXON_ENUM_LIST() [45/113]

enum maxon::THREADTYPE maxon::MAXON_ENUM_LIST ( THREADTYPE  )

◆ MAXON_DATATYPE() [36/73]

maxon::MAXON_DATATYPE ( TimeValue  ,
"net.maxon.datatype.timevalue"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ TupleGet() [1/3]

auto TupleGet ( const Tuple< TYPES ... > &  tup) -> const typename ParameterPack<TYPES...>::template At<I>::type&

TupleGet is the equivalent of std::get. It returns the element at index I.

Example:

Tuple<Int, String> tup(1, "Hello"_s);
Int i = TupleGet<0>(tup);
CString s = TupleGet<1>(tup);
PyObject PyObject const char const char char ** s
Definition: bytesobject.h:60

Note that the index must be a compile-time constant.

If tup is bound to a const&, the element will be returned by const&. If tup is bound to a &, the element will be returned by &. If tup is bound to a &&, the element will be returned by &&.

Template Parameters
IThe index of the element that should be returned.
Parameters
[in]tupThe tuple from which to get the element.
Returns
The returned element.

A TupleGet overload that uses a type to select a unique element. The type must be unique in the given tuple, otherwise a compile-time error will occur.

Example:

Tuple<Int, String> tup(1, "Hello"_s);
Int i = TupleGet<Int>(tup);
CString s = TupleGet<String>(tup);

Note that the index must be a compile-time constant.

If tup is bound to a const&, the element will be returned by const&. If tup is bound to a &, the element will be returned by &. If tup is bound to a &&, the element will be returned by &&.

Template Parameters
ELEMENTTYPEThe type of the element that should be returned (must be unique in the tuple).
Parameters
[in]tupThe tuple from which to get the element.
Returns
The returned element.

◆ TupleGet() [2/3]

auto TupleGet ( Tuple< TYPES ... > &  tup) -> typename ParameterPack<TYPES...>::template At<I>::type&

◆ TupleGet() [3/3]

auto TupleGet ( Tuple< TYPES ... > &&  tup) -> typename ParameterPack<TYPES...>::template At<I>::type&&

◆ TupleExpand() [1/3]

auto maxon::TupleExpand ( const Tuple< TYPES ... > &  tup,
F &&  func 
) -> decltype(maxon::details::ExpandSeqHelperConst(tup, std::forward<F>(func), std::make_index_sequence<sizeof...(TYPES)>()))

TupleExpand unpacks values from a tuple and passes them as arguments to a function, i.e. a function F(TYPES ...) is called with the elements of a Tuple<TYPES ...>.

If tup is bound to a const&, it's elements will be passed by const&. If tup is bound to a &, it's elements will be passed by &. If tup is bound to a &&, it's elements will be passed by &&.

Parameters
[in]tupThe expanded tuple.
[in]funcThe function accepting the tuple elements as arguments.
Returns
The return value of the called function.

◆ TupleExpand() [2/3]

auto maxon::TupleExpand ( Tuple< TYPES ... > &  tup,
F &&  func 
) -> decltype(maxon::details::ExpandSeqHelper(tup, std::forward<F>(func), std::make_index_sequence<sizeof...(TYPES)>()))

◆ TupleExpand() [3/3]

auto maxon::TupleExpand ( Tuple< TYPES ... > &&  tup,
F &&  func 
) -> decltype(maxon::details::ExpandSeqHelper(std::move(tup), std::forward<F>(func), std::make_index_sequence<sizeof...(TYPES)>()))

◆ ToTuple()

auto maxon::ToTuple ( TYPES &&...  args) -> Tuple<typename std::decay<TYPES>::type ...>

ToTuple is a helper function that takes a variable number of arguments and returns them as a tuple. This function is decaying, so any const or reference modifiers will be stripped from the arguments, i.e. if a const T& is passed in, it will be stored as a plain T. ToTuple is the equivalent of std::make_tuple for std::tuple.

Parameters
[in]argsElements of the created tuple.
Returns
A tuple containing args ... .

◆ Tie()

auto maxon::Tie ( TYPES &...  args) -> Tuple<TYPES& ...>

Tie takes a variable number of references and returns them packed as tuple of references. This allows to leverage useful tuple operations, i.e. element-wise converting assignment. Tie is the equivalent of std::tie for std::tuple.

The following example shows how to return a tuple of values from a function and use Tie to simplify the unpacking:

Int a; Int b;
Tie(a, b) = FunctionReturningTuple(x, y, z);
// ... is equivalent to ...
Int a; Int b;
Tuple<Int, Int> result = FunctionReturningTuple(x, y, z);
a = result.first;
b = result.second;
// ... is equivalent to ...
Int a; Int b;
FunctionWithRefOutArgs(x, y, z, a, b); // pass a, b as ref out arguments
PyObject PyObject * result
Definition: abstract.h:43
PyObject * x
Definition: bytesobject.h:38
auto Tie(TYPES &... args) -> Tuple< TYPES &... >
Definition: tuple.h:1177
Parameters
[in]argsA variable number of references.
Returns
A tuple containing args& ... .

◆ ToForwardTuple()

auto maxon::ToForwardTuple ( TYPES &&...  args) -> Tuple<TYPES&& ...>

ToForwardTuple is similar to Tie, but instead of binding arguments to an lvalue reference, it forwards them. This is useful when forwarding arguments into a function that accepts a tuple. Tie is the equivalent of std::forward_as_tuple for std::tuple.

Parameters
[in]argsA variable number of references.
Returns
A tuple containing args&& ... .

◆ TupleForEach() [1/3]

void maxon::TupleForEach ( const Tuple< TYPES ... > &  tup,
F &&  func 
)

TupleForEach applies the given function to all elements of the tuple. This means F must be callable with all element types. This can be accomplished with a function template, or a function object with several overloads.

Parameters
[in]tupThe iterated tuple.
[in]funcA callable object, accepting each tuple element as argument.

◆ TupleForEach() [2/3]

void maxon::TupleForEach ( Tuple< TYPES ... > &  tup,
F &&  func 
)

◆ TupleForEach() [3/3]

void maxon::TupleForEach ( Tuple< TYPES ... > &&  tup,
F &&  func 
)

◆ TupleFold() [1/3]

auto maxon::TupleFold ( const Tuple< TYPES ... > &  tup,
const V &  initialValue,
F &&  func 
) -> V

TupleFold works similar to std::accumulate. It applies a binary function to an initial value and the first element of the tuple, then repeats that for the result and the next element, and so on. The last result is returned by the function. Example:

Tuple<Int, Int, Int> tup1(1, 10, 100);
Int res1 = TupleFold<Int>(t1, 1000, [] (Int a, Int b) { return a + b; });
// res1 is 1000 + 1 + 10 + 100
Tuple<String, String> tup2("Hello"_s, "World"_s);
Int res2 = TupleFold(t2, "Result:"_s, [] (String a, String b) { return a.Append(b); });
// res2 is "Result: Hello World"
auto TupleFold(const Tuple< TYPES ... > &tup, const V &initialValue, F &&func) -> V
Definition: tuple.h:1242
Parameters
[in]tupThe folded tuple.
[in]initialValueThe initial value.
[in]funcA function accepting each tuple element as arguments.
Returns
The folded result value.

◆ TupleFold() [2/3]

auto maxon::TupleFold ( Tuple< TYPES ... > &  tup,
const V &  initialValue,
F &&  func 
) -> V

◆ TupleFold() [3/3]

auto maxon::TupleFold ( Tuple< TYPES ... > &&  tup,
const V &  initialValue,
F &&  func 
) -> V

◆ GetTypeName()

MAXON_ATTRIBUTE_FORCE_INLINE Id maxon::GetTypeName ( )

Returns a compiler-generated name for type T. This is based on the compiler-specific macros FUNCSIG or PRETTY_FUNCTION (see MAXON_FUNCTION_SIGNATURE).

Template Parameters
TA type.
Returns
Compiled-generated name for T.

◆ MAXON_ENUM_LIST() [46/113]

enum maxon::BASE_DIMENSION maxon::MAXON_ENUM_LIST ( BASE_DIMENSION  )

◆ MAXON_REGISTRY() [39/64]

maxon::MAXON_REGISTRY ( Dimension  ,
Dimensions  ,
"net.maxon.registry.dimensions"   
)

◆ MAXON_REGISTRY() [40/64]

maxon::MAXON_REGISTRY ( Unit  ,
Units  ,
"net.maxon.registry.units"   
)

◆ MAXON_ENUM_FLAGS() [20/34]

enum maxon::URLFILECACHEFLAGS maxon::MAXON_ENUM_FLAGS ( URLFILECACHEFLAGS  )

◆ MoveFromWithFilter()

Result<void> maxon::MoveFromWithFilter ( DST dst,
SRC &  src,
const FN &  filter 
)

◆ GetPrintableString()

String maxon::GetPrintableString ( JNIEnv env,
const jstring val 
)

◆ ToString() [2/2]

static String maxon::ToString ( JNIEnv env,
const jstring str 
)
static

◆ CreateCopyWrapper()

Result<CopyWrapper<typename std::decay<T>::type> > maxon::CreateCopyWrapper ( T &&  src)

Creates a CopyWrapper object based on the source object

auto wrapped = CreateCopyWrapper(delegate) iferr_return;
auto lambda =
[callbackWrapper = std::move(wrapped)]() -> Result<void>
{
...
auto& callback = callbackWrapper.Get() iferr_return;
callback(...);
...
};
Result< CopyWrapper< typename std::decay< T >::type > > CreateCopyWrapper(T &&src)
Definition: movecopywrapper.h:138
PyObject * callback
Definition: weakrefobject.h:59
Parameters
[in]srcObject to be copied or moved into the wrapper.
Template Parameters
TType of object to wrapped.
Returns
Wrapped object on success.

◆ NewObjT()

ResultPtr<T> maxon::NewObjT ( ARGS &&...  args)

Creates an object with constructor parameters (using new or T::Alloc, depending on the type). This does not throw any kind of exception, it returns null if the allocation fails. NewObj does not clear the memory. Usage: MyType* x = NewObj(MyType, optional constructor parameters);

Note
Creating a template object will not compile if the template contains a comma, e.g. NewObj(MyType<1,2>). This is due to the nature of how the preprocessor works. To make it work either use NewObjT<>() or declare an alias using MyAllocType = MyType<1,2>; and then pass MyAllocType for the allocation itself.
NewObjT does not support objects which might throw exceptions. THREADSAFE.
Parameters
[in]argsAdditional constructor parameters.
Template Parameters
TType of object.
ARGSAdditional constructor parameter types.
Returns
Pointer to object (null if allocation failed)

◆ DeleteConstPtrObj()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::DeleteConstPtrObj ( T *  o)

Deletes an object. This calls the destructor and frees memory afterwards. Normally you should use DeleteObj(). This variant should be used only in the rare case when the object pointer is a constant so that it can't be set to nullptr.

Note
DeleteConstPtrObj does not support objects which might throw exceptions. THREADSAFE.
Parameters
[in]oObject pointer (can be nullptr)

◆ MAXON_ENUM_LIST() [47/113]

enum maxon::ERROR_OK maxon::MAXON_ENUM_LIST ( ERROR_OK  )

◆ MAXON_ENUM_LIST() [48/113]

enum maxon::ERROR_FAILED maxon::MAXON_ENUM_LIST ( ERROR_FAILED  )

◆ MAXON_ENUM_LIST() [49/113]

enum maxon::ERROR_TYPE maxon::MAXON_ENUM_LIST ( ERROR_TYPE  )

◆ CreateErrorPtr()

const Error* maxon::CreateErrorPtr ( MAXON_SOURCE_LOCATION_DECLARATION  ,
ERROR_TYPE  type 
)
private

CreateErrorPtr is declared as a pure function to allow the compiler to eliminate the call if the error isn't used anywhere. This might happen when iferr is used for error detection only (and the ThreadReferencedError isn't used anywhere).

iferr (Int* ptr = array.Append(42))
return false;
obj._valueIsAt = ptr;
PyObject * obj
Definition: complexobject.h:60
#define iferr(...)
Definition: errorbase.h:388
char ** ptr
Definition: pycore_dtoa.h:13

◆ CreateError()

This function can be used in low-level header files which cannot include error.h, but have to create errors. It can and should only be used in a return statement of a function returning a Result value.

Example:

#define MAXON_SOURCE_LOCATION
Definition: memoryallocationbase.h:67
@ ILLEGAL_ARGUMENT
Create an IllegalArgumentError.
ThreadReferencedError CreateError(MAXON_SOURCE_LOCATION_DECLARATION, ERROR_TYPE type)
Definition: resultbase.h:482

is equivalent to

return IllegalArgumentError(MAXON_SOURCE_LOCATION);

but the former doesn't require to include error.h.

The returned error will be referenced by the current thread.

Parameters
[in]allocLocationUse MAXON_SOURCE_LOCATION as argument so that file and line information is set for the error.
[in]typeThe desired error class.
Returns
Error object of the given class.

◆ PrivateSystemSetCurrentError() [1/2]

const Error* maxon::PrivateSystemSetCurrentError ( const Error &  error)

◆ PrivateSystemSetCurrentError() [2/2]

const Error* maxon::PrivateSystemSetCurrentError ( Error &&  error)

◆ PrivateSetError()

void maxon::PrivateSetError ( Error &  dest,
const Error *  src 
)

◆ MAXON_MEMBERTYPE_DETECTOR() [4/4]

maxon::MAXON_MEMBERTYPE_DETECTOR ( IsForwardRef  ,
IsForwardRef  ,
std::false_type   
)

◆ operator%() [3/20]

MAXON_ATTRIBUTE_FORCE_INLINE auto maxon::operator% ( const ResultOk< T > &  rv,
ThreadReferencedError err 
) -> decltype(rv.GetValue())

◆ operator%() [4/20]

MAXON_ATTRIBUTE_FORCE_INLINE T maxon::operator% ( ResultOk< T > &&  rv,
ThreadReferencedError err 
)

◆ operator%() [5/20]

MAXON_ATTRIBUTE_FORCE_INLINE T& maxon::operator% ( ResultOk< T & > &&  rv,
ThreadReferencedError err 
)

◆ operator%() [6/20]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::operator% ( ResultOk< void > &&  rv,
ThreadReferencedError err 
)

◆ operator%() [7/20]

MAXON_ATTRIBUTE_FORCE_INLINE auto maxon::operator% ( const ResultOk< T > &  rv,
maxon::details::ResultOkError err 
) -> decltype(rv.GetValue())

◆ operator%() [8/20]

MAXON_ATTRIBUTE_FORCE_INLINE T maxon::operator% ( ResultOk< T > &&  rv,
maxon::details::ResultOkError err 
)

◆ operator%() [9/20]

MAXON_ATTRIBUTE_FORCE_INLINE T& maxon::operator% ( ResultOk< T & > &&  rv,
maxon::details::ResultOkError err 
)

◆ operator%() [10/20]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::operator% ( ResultOk< void > &&  rv,
maxon::details::ResultOkError err 
)

◆ operator%() [11/20]

MAXON_ATTRIBUTE_FORCE_INLINE auto maxon::operator% ( const Result< T > &  rv,
ThreadReferencedError err 
) -> decltype(rv.GetValue())

◆ operator%() [12/20]

MAXON_ATTRIBUTE_FORCE_INLINE T maxon::operator% ( Result< T > &&  rv,
ThreadReferencedError err 
)

◆ operator%() [13/20]

MAXON_ATTRIBUTE_FORCE_INLINE T& maxon::operator% ( const Result< T & > &  rv,
ThreadReferencedError err 
)

◆ operator%() [14/20]

MAXON_ATTRIBUTE_FORCE_INLINE T& maxon::operator% ( Result< T & > &&  rv,
ThreadReferencedError err 
)

◆ operator%() [15/20]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::operator% ( const Result< void > &  rv,
ThreadReferencedError err 
)

◆ operator%() [16/20]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::operator% ( Result< void > &&  rv,
ThreadReferencedError err 
)

◆ operator%() [17/20]

MAXON_ATTRIBUTE_FORCE_INLINE T&& maxon::operator% ( ResultMemT< T > &&  ptr,
ThreadReferencedError err 
)

◆ operator%() [18/20]

MAXON_ATTRIBUTE_FORCE_INLINE const T& maxon::operator% ( const ResultMemT< T > &  ptr,
ThreadReferencedError err 
)

◆ operator%() [19/20]

MAXON_ATTRIBUTE_FORCE_INLINE T& maxon::operator% ( ResultRef< T >  ptr,
ThreadReferencedError err 
)

◆ SetSplashMessage()

void maxon::SetSplashMessage ( const String text)

◆ SetSplashImage()

void maxon::SetSplashImage ( const Url url)

◆ SetSplashStartBlocking()

void maxon::SetSplashStartBlocking ( )

◆ SetSplashShow()

void maxon::SetSplashShow ( Bool  show)

◆ DebugPrint()

static MAXON_ATTRIBUTE_FORCE_INLINE void maxon::DebugPrint ( const String str)
static

◆ FreeThreadedStuff()

static void maxon::FreeThreadedStuff ( )
static

◆ GetHResultError()

MAXON_ATTRIBUTE_FORCE_INLINE Error maxon::GetHResultError ( HRESULT  hr,
MAXON_SOURCE_LOCATION_DECLARATION   
)

◆ operator%() [20/20]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::operator% ( HRESULT  value,
ThreadReferencedError err 
)

◆ PropVariantToInt64()

MAXON_ATTRIBUTE_FORCE_INLINE Result<Int64> maxon::PropVariantToInt64 ( const PROPVARIANT &  vt)

Converts a windows VARIANT into a Int64 value with proper error handling.

◆ VariantToInt64()

MAXON_ATTRIBUTE_FORCE_INLINE Result<Int64> maxon::VariantToInt64 ( const VARIANT &  vt)

◆ PropVariantToUniversalDateTime()

MAXON_ATTRIBUTE_FORCE_INLINE Result<UniversalDateTime> maxon::PropVariantToUniversalDateTime ( const PROPVARIANT &  vt)

Converts a windows VARIANT into a DateTime value with proper error handling.

◆ VariantToUniversalDateTime()

MAXON_ATTRIBUTE_FORCE_INLINE Result<UniversalDateTime> maxon::VariantToUniversalDateTime ( const VARIANT &  vt)

◆ ConvertSystemTimeToUniversalDateTime()

UniversalDateTime maxon::ConvertSystemTimeToUniversalDateTime ( const SYSTEMTIME &  st)

◆ FiletimeToUnixTimestamp()

UInt64 maxon::FiletimeToUnixTimestamp ( const FILETIME &  ft)

Converts a FILETIME object to an unsigned integer which can be used when a unix timestamp is needed.

Do not cast a pointer to a FILETIME structure to either a ULARGE_INTEGER* or __int64* value because it can cause alignment faults on 64-bit Windows. See: https://msdn.microsoft.com/en-us/library/ms724284(VS.85).aspx

◆ ConvertFileTimeToUniversalDateTime()

static Result<UniversalDateTime> maxon::ConvertFileTimeToUniversalDateTime ( const FILETIME &  fd,
Bool  filetimeIsUtc 
)
static

Converts a FILETIME object to an UniversaleDateTime object. A FILETIME object can be in UTC or local. https://msdn.microsoft.com/en-us/library/windows/desktop/ms724290(v=vs.85).aspx

Parameters
[in]fdThe object to convert.

◆ ConvertUniversalDateTimeToSystemTime()

SYSTEMTIME maxon::ConvertUniversalDateTimeToSystemTime ( const UniversalDateTime dateTime)

◆ ConvertUniversalDateTimeToFileTime()

FILETIME maxon::ConvertUniversalDateTimeToFileTime ( const UniversalDateTime dateTime)

◆ GetDestructorPointer< corenodes::FrameData >()

◆ MAXON_DECLARATION() [51/89]

maxon::MAXON_DECLARATION ( IoHandler  ,
ZipHandlerImplClass  ,
"net.maxon.iohandler.zip"   
)

◆ MAXON_ATTRIBUTE() [4/16]

maxon::MAXON_ATTRIBUTE ( Id  ,
REDSHIFT_NODESPACE  ,
"com.redshift3d.redshift4c4d.class.nodespace"   
)

◆ MAXON_DECLARATION() [52/89]

maxon::MAXON_DECLARATION ( Class< GlobalImportRef >  ,
GlobalImport  ,
"net.maxon.exchange.class.globalimport"   
)

◆ MAXON_DECLARATION() [53/89]

maxon::MAXON_DECLARATION ( Class< GlobalUtilsRef >  ,
GlobalUtils  ,
"net.maxon.exchange.class.globalutils"   
)

◆ MAXON_ENUM_ORDERED_FLAGS() [2/2]

enum maxon::WIRE_MODE UChar maxon::MAXON_ENUM_ORDERED_FLAGS ( WIRE_MODE  )

◆ MAXON_DATATYPE() [37/73]

maxon::MAXON_DATATYPE ( Wires  ,
"net.maxon.graph.wires"   
)

◆ MAXON_ENUM_ORDERED_LIST() [2/2]

enum maxon::CONNECTION_POSITION maxon::MAXON_ENUM_ORDERED_LIST ( CONNECTION_POSITION  )

◆ Reverse() [4/5]

CONNECTION_POSITION maxon::Reverse ( CONNECTION_POSITION  pos)

Reverses the given connection position. CONNECTION_POSITION::SOURCE becomes CONNECTION_POSITION::TARGET and vice versa, CONNECTION_POSITION::CENTER remains the same.

Parameters
[in]posA connection position.
Returns
The reverse connection position.

◆ MAXON_DATATYPE() [38/73]

maxon::MAXON_DATATYPE ( GraphTransaction  ,
"net.maxon.graph.graphtransaction"   
)

◆ MAXON_DATATYPE() [39/73]

maxon::MAXON_DATATYPE ( GraphNode  ,
"net.maxon.graph.graphnode"   
)

◆ GetConnectionDirection()

PORT_DIR maxon::GetConnectionDirection ( const GraphNode port)

Returns the direction for connections of the given port in the context of the graph model. For an input port this function usually returns PORT_DIR::INPORT, however if the input port is at the root level of the graph model (as defined by GraphModelInterface::GetRootPath(), this is not necessarily the absolute top level because the graph model may be a nested one) then the returned direction is PORT_DIR::OUTPUT because connections will start at the port. Same for output ports.

Parameters
[in]portA port.
Returns
The direction of connections of the port in the context of its graph model.

◆ MAXON_ATTRIBUTE() [5/16]

maxon::MAXON_ATTRIBUTE ( DataDictionary  ,
GraphNodeSelection  ,
"net.maxon.mvp.graphnodeselection"   
)

◆ MAXON_ATTRIBUTE() [6/16]

maxon::MAXON_ATTRIBUTE ( DataDictionary  ,
GraphPortSelection  ,
"net.maxon.mvp.graphportselection"   
)

◆ MAXON_ATTRIBUTE() [7/16]

maxon::MAXON_ATTRIBUTE ( DataDictionary  ,
GraphWireSelection  ,
"net.maxon.mvp.graphwireselection"   
)

◆ SetGraphSelection()

static Result<void> maxon::SetGraphSelection ( const GraphNode root,
const SEL &  selection,
SELECTION_MODE  mode,
const DataDictionary &  userData 
)
static

◆ MAXON_ATTRIBUTE() [8/16]

maxon::MAXON_ATTRIBUTE ( Int  ,
OrderIndex  ,
"orderindex"  ,
MAXON_ATTRIBUTE_READONLY   
)

The OrderIndex attribute is used to define the order of ports within the same parent. The values needn't be contiguous, just their relative order matters.

For a NodeSystem-based graph this is a derived attribute which can't be set directly, you have to set ReqOrderIndex instead. This will be used to derive the value for OrderIndex.

◆ MAXON_ATTRIBUTE() [9/16]

maxon::MAXON_ATTRIBUTE ( Int  ,
InsertIndex  ,
"insertindex"  ,
MAXON_ATTRIBUTE_READONLY   
)

The InsertIndex attribute tells about the temporal order in which sibling ports have been added to the graph. This is not to be confused with OrderIndex which defines the actual order to use.

For a NodeSystem-based graph this is a derived attribute which can't be set directly, you have to set ReqInsertIndex instead. This will be used to derive the value for InsertIndex.

◆ MAXON_ATTRIBUTE() [10/16]

maxon::MAXON_ATTRIBUTE ( Data  ,
PortValue  ,
"value"  ,
MAXON_ATTRIBUTE_READONLY   
)

The PortValue attribute is a derived attribute to query the value of a port, ignoring upstream overrides. The attribute value has to be derived by the graph implementation, typically this takes into account the value of the attribute DESCRIPTION::DATA::BASE::DEFAULTVALUE and, if that value isn't set, the values of connected downstream ports. The value may be overridden by upstream connections to the port, and you have to use the EffectivePortValue attribute to query the final value of a port.

◆ MAXON_ATTRIBUTE() [11/16]

maxon::MAXON_ATTRIBUTE ( Data  ,
EffectivePortValue  ,
"effectivevalue"  ,
MAXON_ATTRIBUTE_READONLY   
)

The EffectivePortValue attribute is a derived attribute to query the effective value of a port. The attribute value has to be derived by the graph implementation, typically this takes into account the PortValue, upstream port connections and also functional nodes which can be evaluated during validation of the graph when their inputs have known values too.

If no effective value can be derived for the port, which includes the case of a port with dynamic value, the effective value is an empty Data.

◆ MAXON_ATTRIBUTE() [12/16]

maxon::MAXON_ATTRIBUTE ( String  ,
EffectiveName  ,
"effectivename"  ,
MAXON_ATTRIBUTE_READONLY   
)

The EffectiveName attribute is a derived attribute which contains the user-visible name of a node or port.

◆ MAXON_ENUM_FLAGS() [21/34]

enum maxon::NODE_KIND maxon::MAXON_ENUM_FLAGS ( NODE_KIND  )

◆ GetPortDirection()

PORT_DIR maxon::GetPortDirection ( NODE_KIND  kind)

Returns the direction of a NODE_KIND. The given kind has to stand for ports or port lists, and the returned value is PORT_DIR::INPUT for input ports and input ports lists, or PORT_DIR::OUTPUT for output ports and output port lists.

Parameters
[in]kindThe kind of a port or port list.
Returns
The corresponding direction.

◆ operator==() [5/8]

Bool maxon::operator== ( const PathBlock a,
const NodePathInterface b 
)

◆ operator!=() [4/7]

Bool maxon::operator!= ( const PathBlock a,
const NodePathInterface b 
)

◆ operator==() [6/8]

Bool maxon::operator== ( const NodePathInterface b,
const PathBlock a 
)

◆ operator!=() [5/7]

Bool maxon::operator!= ( const NodePathInterface b,
const PathBlock a 
)

◆ operator>=()

Bool maxon::operator>= ( const PathBlock a,
const NodePathInterface b 
)

◆ operator<()

Bool maxon::operator< ( const PathBlock a,
const NodePathInterface b 
)

◆ operator>()

Bool maxon::operator> ( const PathBlock a,
const NodePathInterface b 
)

◆ operator<=()

Bool maxon::operator<= ( const PathBlock a,
const NodePathInterface b 
)

◆ operator+() [2/2]

Result<NodePath> maxon::operator+ ( const PathBlock a,
const NodePath &  b 
)

◆ MAXON_DECLARATION() [54/89]

maxon::MAXON_DECLARATION ( Class< AudioObjectRef >  ,
AudioObjectClass  ,
"net.maxon.image.class.audioobject"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

◆ MAXON_DATATYPE() [40/73]

maxon::MAXON_DATATYPE ( DrawDimensionInt  ,
"net.maxon.image.drawdimensionint"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

◆ MAXON_DATATYPE() [41/73]

maxon::MAXON_DATATYPE ( DrawDimensionFloat  ,
"net.maxon.image.drawdimensionfloat"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

◆ MAXON_DATATYPE() [42/73]

maxon::MAXON_DATATYPE ( DrawRectInt  ,
"net.maxon.image.drawrectint"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

◆ MAXON_DATATYPE() [43/73]

maxon::MAXON_DATATYPE ( DrawRectFloat  ,
"net.maxon.image.drawrectfloat"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

◆ MAXON_DATATYPE() [44/73]

maxon::MAXON_DATATYPE ( DrawPoint3dInt  ,
"net.maxon.image.drawpoint3dint"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

◆ MAXON_DATATYPE() [45/73]

maxon::MAXON_DATATYPE ( DrawPoint3dFloat  ,
"net.maxon.image.drawpoint3dfloat"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

◆ MAXON_DATATYPE() [46/73]

maxon::MAXON_DATATYPE ( DrawDimension3dInt  ,
"net.maxon.image.drawdimension3dint"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

◆ MAXON_DATATYPE() [47/73]

maxon::MAXON_DATATYPE ( DrawDimension3dFloat  ,
"net.maxon.image.drawdimension3dfloat"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

◆ MAXON_DATATYPE() [48/73]

maxon::MAXON_DATATYPE ( DrawVolumeInt  ,
"net.maxon.image.drawvolumeint"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

◆ MAXON_DATATYPE() [49/73]

maxon::MAXON_DATATYPE ( DrawVolumeFloat  ,
"net.maxon.image.drawvolumefloat"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

◆ MAXON_DATATYPE() [50/73]

maxon::MAXON_DATATYPE ( BITS  ,
"net.maxon.image.bits"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

◆ MAXON_ENUM_LIST() [50/113]

enum maxon::COLORPROFILEINFO maxon::MAXON_ENUM_LIST ( COLORPROFILEINFO  )

◆ MAXON_ENUM_LIST() [51/113]

enum maxon::COLORCONVERSIONINTENT maxon::MAXON_ENUM_LIST ( COLORCONVERSIONINTENT  )

◆ MAXON_ENUM_FLAGS() [22/34]

enum maxon::COLORCONVERSIONFLAGS maxon::MAXON_ENUM_FLAGS ( COLORCONVERSIONFLAGS  )

◆ SRGBtoLinear()

T maxon::SRGBtoLinear ( const T &  v)

◆ LinearToSRGB()

T maxon::LinearToSRGB ( const T &  v)

◆ MAXON_REGISTRY() [41/64]

maxon::MAXON_REGISTRY ( ColorProfile  ,
ColorProfiles  ,
"net.maxon.image.registry.colorprofiles"   
)

◆ MAXON_REGISTRY() [42/64]

maxon::MAXON_REGISTRY ( ColorSpace  ,
ColorSpaces  ,
"net.maxon.image.registry.colorspaces"   
)

Registry for color spaces.

◆ MAXON_REGISTRY() [43/64]

maxon::MAXON_REGISTRY ( ImageChannelType  ,
ImageChannelTypes  ,
"net.maxon.image.registry.imagechanneltypes"   
)

◆ ConvertPixel() [1/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8u dst,
const Pix8u  src 
)

Converts a single component from one pixel depth to another. Supported Pixel types are: Pix8u, Pix16u, Pix32f. Proper rounding will be performed.

◆ ConvertPixel() [2/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8u dst,
const Pix8s  src 
)

◆ ConvertPixel() [3/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8u dst,
const Pix16u  src 
)

◆ ConvertPixel() [4/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8u dst,
const Pix16s  src 
)

◆ ConvertPixel() [5/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8u dst,
const Pix32u  src 
)

◆ ConvertPixel() [6/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8u dst,
const Pix32s  src 
)

◆ ConvertPixel() [7/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8u dst,
const Pix32f  src 
)

◆ ConvertPixel() [8/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8u dst,
const Pix64f  src 
)

◆ ConvertPixel() [9/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16u dst,
const Pix8u  src 
)

◆ ConvertPixel() [10/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16u dst,
const Pix8s  src 
)

◆ ConvertPixel() [11/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16u dst,
const Pix16u  src 
)

◆ ConvertPixel() [12/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16u dst,
const Pix16s  src 
)

◆ ConvertPixel() [13/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16u dst,
const Pix32u  src 
)

◆ ConvertPixel() [14/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16u dst,
const Pix32s  src 
)

◆ ConvertPixel() [15/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16u dst,
const Pix32f  src 
)

◆ ConvertPixel() [16/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16u dst,
const Pix64f  src 
)

◆ ConvertPixel() [17/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32u dst,
const Pix8u  src 
)

◆ ConvertPixel() [18/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32u dst,
const Pix8s  src 
)

◆ ConvertPixel() [19/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32u dst,
const Pix16u  src 
)

◆ ConvertPixel() [20/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32u dst,
const Pix16s  src 
)

◆ ConvertPixel() [21/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32u dst,
const Pix32u  src 
)

◆ ConvertPixel() [22/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32u dst,
const Pix32s  src 
)

◆ ConvertPixel() [23/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32u dst,
const Pix32f  src 
)

◆ ConvertPixel() [24/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32u dst,
const Pix64f  src 
)

◆ ConvertPixel() [25/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8s dst,
const Pix8u  src 
)

to signed

◆ ConvertPixel() [26/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8s dst,
const Pix8s  src 
)

◆ ConvertPixel() [27/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8s dst,
const Pix16u  src 
)

◆ ConvertPixel() [28/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8s dst,
const Pix16s  src 
)

◆ ConvertPixel() [29/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8s dst,
const Pix32u  src 
)

◆ ConvertPixel() [30/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8s dst,
const Pix32s  src 
)

◆ ConvertPixel() [31/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8s dst,
const Pix32f  src 
)

◆ ConvertPixel() [32/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix8s dst,
const Pix64f  src 
)

◆ ConvertPixel() [33/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16s dst,
const Pix8u  src 
)

◆ ConvertPixel() [34/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16s dst,
const Pix8s  src 
)

◆ ConvertPixel() [35/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16s dst,
const Pix16u  src 
)

◆ ConvertPixel() [36/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16s dst,
const Pix16s  src 
)

◆ ConvertPixel() [37/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16s dst,
const Pix32u  src 
)

◆ ConvertPixel() [38/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16s dst,
const Pix32s  src 
)

◆ ConvertPixel() [39/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16s dst,
const Pix32f  src 
)

◆ ConvertPixel() [40/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16s dst,
const Pix64f  src 
)

◆ ConvertPixel() [41/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32s dst,
const Pix8u  src 
)

◆ ConvertPixel() [42/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32s dst,
const Pix8s  src 
)

◆ ConvertPixel() [43/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32s dst,
const Pix16u  src 
)

◆ ConvertPixel() [44/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32s dst,
const Pix16s  src 
)

◆ ConvertPixel() [45/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32s dst,
const Pix32u  src 
)

◆ ConvertPixel() [46/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32s dst,
const Pix32s  src 
)

◆ ConvertPixel() [47/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32s dst,
const Pix32f  src 
)

◆ ConvertPixel() [48/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32s dst,
const Pix64f  src 
)

◆ ConvertPixel() [49/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Float32 dst,
const Pix8u  src 
)

◆ ConvertPixel() [50/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Float64 dst,
const Pix8u  src 
)

◆ ConvertPixel() [51/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32f dst,
const Pix16u  src 
)

◆ ConvertPixel() [52/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32f dst,
const Pix32u  src 
)

◆ ConvertPixel() [53/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32f dst,
const Pix32s  src 
)

◆ ConvertPixel() [54/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32f dst,
const Pix32f  src 
)

◆ ConvertPixel() [55/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix32f dst,
const Pix64f  src 
)

◆ ConvertPixel() [56/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix64f dst,
const Pix16u  src 
)

◆ ConvertPixel() [57/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix64f dst,
const Pix32u  src 
)

◆ ConvertPixel() [58/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix64f dst,
const Pix32s  src 
)

◆ ConvertPixel() [59/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix64f dst,
const Pix32f  src 
)

◆ ConvertPixel() [60/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix64f dst,
const Pix64f  src 
)

◆ ConvertPixel() [61/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16f dst,
const Pix8u  src 
)

◆ ConvertPixel() [62/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16f dst,
const Pix16u  src 
)

◆ ConvertPixel() [63/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16f dst,
const Pix32u  src 
)

◆ ConvertPixel() [64/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16f dst,
const Pix32s  src 
)

◆ ConvertPixel() [65/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16f dst,
const Pix16f  src 
)

◆ ConvertPixel() [66/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16f dst,
const Pix32f  src 
)

◆ ConvertPixel() [67/67]

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::ConvertPixel ( Pix16f dst,
const Pix64f  src 
)

◆ IsPixelIdentical()

MAXON_ATTRIBUTE_FORCE_INLINE Bool maxon::IsPixelIdentical ( PIXELDEPTH  a,
PIXELDEPTH  b,
PIXELDEPTH  oneTolerance 
)

Compares 2 Pixel values with a given tolerance.

Parameters
[in]aPixel Value 1.
[in]bPixel Value 2.
[in]oneToleranceTolerance of the pixel in the [0..255] range. If the PIXELDEPTH is different to Pix8u it will be converted by using the contant defined in PixelDepthInfo<PIXELDEPTH>::PIXELTOLERANCE_ONE.
Returns
True if the difference is below the given tolerance.

◆ MAXON_REGISTRY() [44/64]

maxon::MAXON_REGISTRY ( Class< ImagePixelStorage >  ,
ImagePixelStorageClasses  ,
"net.maxon.image.registry.imagepixelstorageclasses"   
)

◆ MAXON_DATATYPE() [51/73]

maxon::MAXON_DATATYPE ( UpdateRegion  ,
"net.maxon.image.updateregion"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

◆ MAXON_DECLARATION() [55/89]

maxon::MAXON_DECLARATION ( Class< ImageRegionTilesObserverRef >  ,
ImageRegionSingleTileObserverClass  ,
"net.maxon.class.imageregionobserver.tiles"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

Performs a per-tile AABB tracking of changes. The class is thread-safe for conditions where production and consumption of region changes are performed on different threads.

◆ MAXON_ENUM_LIST() [52/113]

enum maxon::LAYERSETMODE maxon::MAXON_ENUM_LIST ( LAYERSETMODE  )

◆ MAXON_DECLARATION() [56/89]

maxon::MAXON_DECLARATION ( Class< MediaStreamAudioDataExportRef >  ,
MediaStreamAudioDataExportClass  ,
"net.maxon.image.class.mediastreamaudiodataexport"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

◆ MediaTraverseChildren()

static Result<Bool> maxon::MediaTraverseChildren ( const REFTYPE &  t,
const ConstDataPtr branch,
const Delegate< Result< Bool >(const REFTYPE &child, const REFTYPE &parent, const ConstDataPtr &branch, Int depth)> &  func,
Int  depth = 0 
)
static

Helper function to traverse all children of the root object t.

MediaStreamRef stream; // object with hierarchy to run through
BaseArray<MediaStreamRef> res;
MediaTraverseChildren<MediaStreamRef>(stream, ConstDataPtr(),
[&res](const MediaStreamRef& child, const MediaStreamRef& parent, const ConstDataPtr& branch, Int depth) -> Result<Bool>
{
res.Append(child) iferr_return;
return true;
}, 0) iferr_return;
Parameters
[in]tobject to iterate.
[in]funcfunction which is called for each object.
Returns
returns false if iteration should stop. otherwise true to continue.

◆ MediaTraverseMeAndChildren()

static Result<Bool> maxon::MediaTraverseMeAndChildren ( const REFTYPE &  t,
const REFTYPE &  parent,
const ConstDataPtr branch,
const Delegate< Result< Bool >(const REFTYPE &child, const REFTYPE &parent, const ConstDataPtr &branch, Int depth)> &  func,
Int  depth = 0 
)
static

Helper function to traverse all children of the root object t, but also the given object.

MediaStreamRef stream; // object with hierarchy to run through
BaseArray<MediaStreamRef> res;
MediaTraverseMeAndChildren<MediaStreamRef>(stream, MediaStreamRef(), ConstDataPtr(),
[&res](const MediaStreamRef& child, const MediaStreamRef& parent, const ConstDataPtr& branch, Int depth) -> Result<Bool>
{
res.Append(child) iferr_return;
return true;
Parameters
[in]tobject to iterate.
[in]funcfunction which is called for each object.
Returns
returns false if iteration should stop. otherwise true to continue.

◆ MAXON_ENUM_LIST() [53/113]

enum maxon::MEDIAFORMATTYPE maxon::MAXON_ENUM_LIST ( MEDIAFORMATTYPE  )

◆ MAXON_ENUM_LIST() [54/113]

enum maxon::MEDIAALPHATYPE maxon::MAXON_ENUM_LIST ( MEDIAALPHATYPE  )

◆ MAXON_DECLARATION() [57/89]

maxon::MAXON_DECLARATION ( Class< MediaBaseRef >  ,
MediaBaseClass  ,
"net.maxon.image.class.mediabase"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

◆ MAXON_DECLARATION() [58/89]

maxon::MAXON_DECLARATION ( Class< MediaConverterRef >  ,
MediaConverterBaseClass  ,
"net.maxon.image.class.mediaconverterbase"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

◆ MAXON_DECLARATION() [59/89]

maxon::MAXON_DECLARATION ( Class< FileFormat >  ,
FileFormatImageBaseClass  ,
"net.maxon.image.class.fileformatimagebase"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

This class should be added to your own image fileformat implementation. It implements default values for GetData() for FILEFORMATPROPERTIES of images.

◆ MAXON_REGISTRY() [45/64]

maxon::MAXON_REGISTRY ( Class< MediaOutputUrlRef >  ,
ImageSaverClasses  ,
"net.maxon.image.registry.imagesaverclasses"   
)

Registry to register all image saver.

◆ MAXON_ENUM_LIST() [55/113]

enum maxon::RLACHANNELS maxon::MAXON_ENUM_LIST ( RLACHANNELS  )

◆ MAXON_ENUM_FLAGS() [23/34]

enum maxon::RLAFLAGS maxon::MAXON_ENUM_FLAGS ( RLAFLAGS  )

◆ GetRlaRpfChannelSymbol()

Char maxon::GetRlaRpfChannelSymbol ( RLACHANNELS  channel)

◆ GetRlaRpfChannelSize()

Int maxon::GetRlaRpfChannelSize ( RLACHANNELS  channel)

◆ GetRlaRpfChannelType()

Tuple<ImageChannel, ImageChannel, ImageChannel> maxon::GetRlaRpfChannelType ( RLACHANNELS  channel)

◆ ToWindowsTime()

Int64 maxon::ToWindowsTime ( const TimeValue time)

◆ ToMaxonTime()

TimeValue maxon::ToMaxonTime ( Int64  time)

◆ FpsToInt()

Vec2<Int> maxon::FpsToInt ( Float  fps)

◆ MAXON_ENUM_FLAGS() [24/34]

enum maxon::SELECTIONHANDLERRESULT maxon::MAXON_ENUM_FLAGS ( SELECTIONHANDLERRESULT  )

◆ MAXON_DECLARATION() [60/89]

maxon::MAXON_DECLARATION ( Class< MediaOutputRef >  ,
MediaOutputBaseClass  ,
"net.maxon.image.class.mediaoutputbase"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

◆ MAXON_DECLARATION() [61/89]

maxon::MAXON_DECLARATION ( Class< MediaOutputTextureRef >  ,
MediaOutputTextureClass  ,
"net.maxon.image.class.mediaoutputtexture"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

◆ MAXON_DECLARATION() [62/89]

maxon::MAXON_DECLARATION ( Class< MediaOutputUrlRef >  ,
MediaOutputUrlBaseClass  ,
"net.maxon.image.class.mediaoutputurlbase"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

◆ MediaSessionImport()

Result<MediaSessionRef> maxon::MediaSessionImport ( const Url fileName,
const TimeValue targetTime,
MEDIASESSIONFLAGS  flags,
const MediaOutputRef &  outputConverter,
const MediaOutputSelectionHandler selectionHandler,
const MediaSessionProgressCallback progressCallback,
const FileFormatHandler &  preferredHandler,
const ValueReceiver< const FileFormatHandler & > &  fileFormats = {} 
)

Helper function to load a image or movie into any MediaOutputRef. this allows to load images/movies directly to the place it belongs to (e.g. directly to any opengl buffer).

Parameters
[in]fileNameUrl to load.
[in]targetTimeFrame to load from a stream. TimeValue() will load the first frame.
[in]flagsSee MEDIASESSIONFLAGS for details.
[in]outputConverterMediaOutputRef which is setup to load the data in.
[in]selectionHandlerOptional handler which is called to filter which elements should be loaded.
[in]progressCallbackOptional callback to receive the progress of the loader.
[in]preferredHandlerThis is a optional parameter which allows to give a preferred handler (which could be already detected before).
Returns
A valid MediaSessionRef on success. This session can optionally be used to load subsequent images into the same buffers by calling session.Convert(time) again.

◆ MAXON_ENUM_FLAGS() [25/34]

enum maxon::MEDIASESSIONFLAGS maxon::MAXON_ENUM_FLAGS ( MEDIASESSIONFLAGS  )

◆ MAXON_DECLARATION() [63/89]

maxon::MAXON_DECLARATION ( Class< MediaSessionRef >  ,
MediaSessionObject  ,
"net.maxon.image.class.mediasessionobject"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

◆ MAXON_DECLARATION() [64/89]

maxon::MAXON_DECLARATION ( Class< MediaStreamRef >  ,
MediaStreamBaseClass  ,
"net.maxon.image.class.mediastreambase"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

◆ MAXON_DECLARATION() [65/89]

maxon::MAXON_DECLARATION ( Class< MediaStreamExifDataRef >  ,
MediaStreamExifDataClass  ,
"net.maxon.image.class.mediastreamexifdata"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

◆ MAXON_DECLARATION() [66/89]

maxon::MAXON_DECLARATION ( Class< MediaStreamImageBaseRef >  ,
MediaStreamImageBaseClass  ,
"net.maxon.image.class.mediastreamimagebase"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

◆ MAXON_DECLARATION() [67/89]

maxon::MAXON_DECLARATION ( Class< MediaStreamImageDataImportRef >  ,
MediaStreamImageDataImportClass  ,
"net.maxon.image.class.mediastreamimagedataimport"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

◆ MAXON_DECLARATION() [68/89]

maxon::MAXON_DECLARATION ( Class< MediaStreamImageDataExportRef >  ,
MediaStreamImageDataExportClass  ,
"net.maxon.image.class.mediastreamimagedataexport"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

◆ MAXON_DECLARATION() [69/89]

maxon::MAXON_DECLARATION ( Class< MediaStreamAudioDataImportRef >  ,
MediaStreamAudioDataImportClass  ,
"net.maxon.image.class.mediastreamaudiodataimport"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

◆ MAXON_DECLARATION() [70/89]

maxon::MAXON_DECLARATION ( Class< MediaStreamImageDataForwardImportRef >  ,
MediaStreamForwardImageDataStreamsImportClass  ,
"net.maxon.image.class.mediastreamforwardimagedatastreamsimport"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

◆ GetSelectedFormatPreferAspectRatio_1_1()

Result<Data> maxon::GetSelectedFormatPreferAspectRatio_1_1 ( const MediaStreamRef &  stream,
MediaStreamFormat &  resFormat 
)

GetSelectedFormatPreferAspectRatio_1_1 tries to find a format with a 1:1 aspect ratio.

Parameters
[in]streamStream to determine.
[in]resFormatReturns the MediaStreamFormat of the preferred format.
Returns
Returns the preferred format.

◆ MAXON_DECLARATION() [71/89]

maxon::MAXON_DECLARATION ( Class< MediaStreamFormat >  ,
MediaStreamFormatClass  ,
"net.maxon.image.class.mediastreamformat"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

◆ MAXON_DECLARATION() [72/89]

maxon::MAXON_DECLARATION ( Class< MediaStreamProperties >  ,
MediaStreamPropertiesClass  ,
"net.maxon.image.class.mediastreamproperties"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.image")   
)

◆ BlendOver()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendOver ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Implementations of commonly used blend modes which can be applied per-component.

Blend Modes Blend results are not necessarily meant to match the result in Photoshop (or any other application). Photoshop in particular has some rather "creative" alpha handling which is not attempted to be reproduced here. Moreover, Photoshop doesn't support half of their blend modes in 32-bit mode, so it's impossible to compare results in any meaningful way.

These implementations are mostly based on those from Bodypaint as well as the Fusion shader. Over (Normal)

◆ BlendAverage()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendAverage ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Average.

◆ BlendMultiply()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendMultiply ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Multiply.

◆ BlendScreen()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendScreen ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Screen.

◆ BlendSubtract()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendSubtract ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Subtract.

◆ BlendDivide()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendDivide ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Divide.

◆ BlendAdd()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendAdd ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Add.

◆ BlendOverlay()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendOverlay ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Overlay.

◆ BlendHardLight()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendHardLight ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Hard Light.

◆ BlendSoftLight()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendSoftLight ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Soft Light.

◆ BlendDarken()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendDarken ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Darken (Min)

◆ BlendLighten()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendLighten ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Lighten (Max)

◆ BlendPinLight()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendPinLight ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Pin Light.

◆ BlendDifference()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendDifference ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Difference.

◆ BlendExclusion()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendExclusion ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Exclusion.

◆ BlendNegative()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendNegative ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Negative.

◆ BlendStamp()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendStamp ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Stamp.

◆ BlendXor()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendXor ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Xor.

◆ BlendGlow()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendGlow ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Glow.

◆ BlendReflect()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendReflect ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Reflect.

◆ BlendHeat()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendHeat ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Heat.

◆ BlendFreeze()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendFreeze ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Freeze.

◆ BlendHypot()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendHypot ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Hypot (similar effect to screen but a bit weaker)

◆ Dissolve()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::Dissolve ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Dissolve.

◆ BlendHardMix()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendHardMix ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Hard Mix.

◆ BlendColorDodge()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendColorDodge ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Color Dodge.

◆ BlendColorBurn()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendColorBurn ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Color Burn.

◆ BlendLinearDodge()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendLinearDodge ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Linear Dodge.

◆ BlendLinearBurn()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendLinearBurn ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Linear Burn.

◆ BlendVividLight()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::BlendVividLight ( FLOATTYPE  background,
FLOATTYPE  foreground 
)

Vivid Light.

◆ BlendHue()

MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE maxon::BlendHue ( const COLORTYPE &  background,
const COLORTYPE &  foreground 
)

Hue.

"Complex" blend modes These modes cannot be applied per-component. Alpha has no meaning with these blend modes, so we just return the background layer's alpha value.

◆ BlendSaturation()

MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE maxon::BlendSaturation ( const COLORTYPE &  background,
const COLORTYPE &  foreground 
)

Saturation.

◆ BlendLuminance()

MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE maxon::BlendLuminance ( const COLORTYPE &  background,
const COLORTYPE &  foreground 
)

Luminance.

◆ BlendColor()

MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE maxon::BlendColor ( const COLORTYPE &  background,
const COLORTYPE &  foreground 
)

Color.

◆ BlendLevr()

MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE maxon::BlendLevr ( const COLORTYPE &  background,
const COLORTYPE &  foreground 
)

Levr.

◆ LuminanceColor()

static MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE::ValueType maxon::LuminanceColor ( const COLORTYPE &  color)
static

◆ LuminanceColorA()

static MAXON_ATTRIBUTE_FORCE_INLINE COLORATYPE::ValueType maxon::LuminanceColorA ( const COLORATYPE &  color)
static

◆ BlendDarker()

MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE maxon::BlendDarker ( const COLORTYPE &  background,
const COLORTYPE &  foreground 
)

Darker.

◆ BlendLighter()

MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE maxon::BlendLighter ( const COLORTYPE &  background,
const COLORTYPE &  foreground 
)

Lighter.

◆ MAXON_ENUM_LIST() [56/113]

enum maxon::BLEND_MODES maxon::MAXON_ENUM_LIST ( BLEND_MODES  )

◆ BlendRGBA()

static MAXON_ATTRIBUTE_FORCE_INLINE COLORATYPE maxon::BlendRGBA ( const COLORATYPE &  background,
const COLORATYPE &  foreground,
typename COLORATYPE::ValueType  opacity 
)
static

◆ XyzToRgb()

MAXON_ATTRIBUTE_FORCE_INLINE Color maxon::XyzToRgb ( const Color xyz)

◆ RgbToXyz()

MAXON_ATTRIBUTE_FORCE_INLINE Color maxon::RgbToXyz ( const Color rgb)

◆ RgbToCmy()

MAXON_ATTRIBUTE_FORCE_INLINE Color maxon::RgbToCmy ( const Color  rgb)

◆ CmyToRgb()

MAXON_ATTRIBUTE_FORCE_INLINE Color maxon::CmyToRgb ( const Color  cmy)

◆ RgbToHsv()

MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE maxon::RgbToHsv ( const COLORTYPE &  rgb)

◆ HsvToRgb()

MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE maxon::HsvToRgb ( const COLORTYPE &  hsv)

◆ RgbToHsl()

MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE maxon::RgbToHsl ( const COLORTYPE &  rgb)

◆ Value()

MAXON_ATTRIBUTE_FORCE_INLINE FLOATTYPE maxon::Value ( FLOATTYPE  nl,
FLOATTYPE  n2,
FLOATTYPE  hue 
)

◆ HslToRgb()

MAXON_ATTRIBUTE_FORCE_INLINE COLORTYPE maxon::HslToRgb ( const COLORTYPE &  hsl)

◆ ColorTemperatureToRGB()

MAXON_ATTRIBUTE_FORCE_INLINE Color maxon::ColorTemperatureToRGB ( Float  temperature)

Returns the color of an ideal black-body radiator at the given temperature. https://en.wikipedia.org/wiki/Color_temperature

◆ Fract()

MAXON_ATTRIBUTE_FORCE_INLINE enable_if_float<T> maxon::Fract ( value)

◆ Invert()

MAXON_ATTRIBUTE_FORCE_INLINE enable_if_float<T> maxon::Invert ( value)

◆ ClampValueCustom()

MAXON_ATTRIBUTE_FORCE_INLINE enable_if_scalar<T> maxon::ClampValueCustom ( value,
lowerLimit,
upperLimit 
)

◆ MinCustom()

MAXON_ATTRIBUTE_FORCE_INLINE enable_if_scalar<T> maxon::MinCustom ( a,
b 
)

◆ MaxCustom()

MAXON_ATTRIBUTE_FORCE_INLINE enable_if_scalar<T> maxon::MaxCustom ( a,
b 
)

◆ SignNoTemplate()

MAXON_ATTRIBUTE_FORCE_INLINE enable_if_scalar<T> maxon::SignNoTemplate ( value)

◆ FMod()

MAXON_ATTRIBUTE_FORCE_INLINE enable_if_integral<T> maxon::FMod ( a,
b 
)

◆ MapRange()

MAXON_ATTRIBUTE_FORCE_INLINE enable_if_scalar<T> maxon::MapRange ( input,
inputMin,
inputMax,
outputMin,
outputMax 
)

◆ Step()

MAXON_ATTRIBUTE_FORCE_INLINE enable_if_float<T> maxon::Step ( value,
threshold 
)

◆ Quantize()

MAXON_ATTRIBUTE_FORCE_INLINE enable_if_float<T> maxon::Quantize ( value,
steps 
)

◆ Cbrt()

MAXON_ATTRIBUTE_FORCE_INLINE enable_if_float<T> maxon::Cbrt ( input)

◆ SquaredLength() [1/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::SquaredLength ( const Vector2d32 input)

◆ SquaredLength() [2/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::SquaredLength ( const Vector2d64 input)

◆ SquaredLength() [3/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::SquaredLength ( const Vector32 input)

◆ SquaredLength() [4/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::SquaredLength ( const Vector64 input)

◆ SquaredLength() [5/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::SquaredLength ( const Vector4d32 input)

◆ SquaredLength() [6/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::SquaredLength ( const Vector4d64 input)

◆ SquaredLength() [7/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::SquaredLength ( const Color32 input)

◆ SquaredLength() [8/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::SquaredLength ( const Color64 input)

◆ SquaredLength() [9/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::SquaredLength ( const ColorA32 input)

◆ SquaredLength() [10/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::SquaredLength ( const ColorA64 input)

◆ Length() [1/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Length ( const Vector2d32 input)

◆ Length() [2/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Length ( const Vector2d64 input)

◆ Length() [3/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Length ( const Vector32 input)

◆ Length() [4/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Length ( const Vector64 input)

◆ Length() [5/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Length ( const Vector4d32 input)

◆ Length() [6/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Length ( const Vector4d64 input)

◆ Length() [7/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Length ( const Color32 input)

◆ Length() [8/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Length ( const Color64 input)

◆ Length() [9/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::Length ( const ColorA32 input)

◆ Length() [10/10]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::Length ( const ColorA64 input)

◆ SafePow() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float64 maxon::SafePow ( Float64  v1,
Float64  v2 
)

◆ SafePow() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE Float32 maxon::SafePow ( Float32  v1,
Float32  v2 
)

◆ SafeSqrt() [1/2]

◆ SafeSqrt() [2/2]

◆ MATH_HELPER_INSTANTIATE() [1/41]

maxon::MATH_HELPER_INSTANTIATE ( Clamp01  )

◆ MATH_HELPER_INSTANTIATE() [2/41]

maxon::MATH_HELPER_INSTANTIATE ( ATan2  )

◆ MATH_HELPER_INSTANTIATE() [3/41]

maxon::MATH_HELPER_INSTANTIATE ( Exp  )

◆ MATH_HELPER_INSTANTIATE() [4/41]

maxon::MATH_HELPER_INSTANTIATE ( Exp2  )

◆ MATH_HELPER_INSTANTIATE() [5/41]

maxon::MATH_HELPER_INSTANTIATE ( Ln  )

◆ MATH_HELPER_INSTANTIATE() [6/41]

maxon::MATH_HELPER_INSTANTIATE ( Log10  )

◆ MATH_HELPER_INSTANTIATE() [7/41]

maxon::MATH_HELPER_INSTANTIATE ( Log2  )

◆ MATH_HELPER_INSTANTIATE() [8/41]

maxon::MATH_HELPER_INSTANTIATE ( Gamma  )

◆ MATH_HELPER_INSTANTIATE() [9/41]

maxon::MATH_HELPER_INSTANTIATE ( Si  )

◆ MATH_HELPER_INSTANTIATE() [10/41]

maxon::MATH_HELPER_INSTANTIATE ( Sinc  )

◆ MATH_HELPER_INSTANTIATE() [11/41]

maxon::MATH_HELPER_INSTANTIATE ( Abs  )

◆ MATH_HELPER_INSTANTIATE() [12/41]

maxon::MATH_HELPER_INSTANTIATE ( Ceil  )

◆ MATH_HELPER_INSTANTIATE() [13/41]

maxon::MATH_HELPER_INSTANTIATE ( Floor  )

◆ MATH_HELPER_INSTANTIATE() [14/41]

maxon::MATH_HELPER_INSTANTIATE ( Round  )

◆ MATH_HELPER_INSTANTIATE() [15/41]

maxon::MATH_HELPER_INSTANTIATE ( ClampValueCustom  )

◆ MATH_HELPER_INSTANTIATE() [16/41]

maxon::MATH_HELPER_INSTANTIATE ( MinCustom  )

◆ MATH_HELPER_INSTANTIATE() [17/41]

maxon::MATH_HELPER_INSTANTIATE ( MaxCustom  )

◆ MATH_HELPER_INSTANTIATE() [18/41]

maxon::MATH_HELPER_INSTANTIATE ( Fract  )

◆ MATH_HELPER_INSTANTIATE() [19/41]

maxon::MATH_HELPER_INSTANTIATE ( Invert  )

◆ MATH_HELPER_INSTANTIATE() [20/41]

maxon::MATH_HELPER_INSTANTIATE ( FMod  )

◆ MATH_HELPER_INSTANTIATE() [21/41]

maxon::MATH_HELPER_INSTANTIATE ( MapRange  )

◆ MATH_HELPER_INSTANTIATE() [22/41]

maxon::MATH_HELPER_INSTANTIATE ( Inverse  )

◆ MATH_HELPER_INSTANTIATE() [23/41]

maxon::MATH_HELPER_INSTANTIATE ( SignNoTemplate  )

◆ MATH_HELPER_INSTANTIATE() [24/41]

maxon::MATH_HELPER_INSTANTIATE ( SmoothStep  )

◆ MATH_HELPER_INSTANTIATE() [25/41]

maxon::MATH_HELPER_INSTANTIATE ( BoxStep  )

◆ MATH_HELPER_INSTANTIATE() [26/41]

maxon::MATH_HELPER_INSTANTIATE ( Step  )

◆ MATH_HELPER_INSTANTIATE() [27/41]

maxon::MATH_HELPER_INSTANTIATE ( Quantize  )

◆ MATH_HELPER_INSTANTIATE() [28/41]

maxon::MATH_HELPER_INSTANTIATE ( Pow  )

◆ MATH_HELPER_INSTANTIATE() [29/41]

maxon::MATH_HELPER_INSTANTIATE ( Sqrt  )

◆ MATH_HELPER_INSTANTIATE() [30/41]

maxon::MATH_HELPER_INSTANTIATE ( Cbrt  )

◆ MATH_HELPER_INSTANTIATE() [31/41]

maxon::MATH_HELPER_INSTANTIATE ( Sin  )

◆ MATH_HELPER_INSTANTIATE() [32/41]

maxon::MATH_HELPER_INSTANTIATE ( Cos  )

◆ MATH_HELPER_INSTANTIATE() [33/41]

maxon::MATH_HELPER_INSTANTIATE ( Tan  )

◆ MATH_HELPER_INSTANTIATE() [34/41]

maxon::MATH_HELPER_INSTANTIATE ( Sinh  )

◆ MATH_HELPER_INSTANTIATE() [35/41]

maxon::MATH_HELPER_INSTANTIATE ( Cosh  )

◆ MATH_HELPER_INSTANTIATE() [36/41]

maxon::MATH_HELPER_INSTANTIATE ( Tanh  )

◆ MATH_HELPER_INSTANTIATE() [37/41]

maxon::MATH_HELPER_INSTANTIATE ( ASin  )

◆ MATH_HELPER_INSTANTIATE() [38/41]

maxon::MATH_HELPER_INSTANTIATE ( ACos  )

◆ MATH_HELPER_INSTANTIATE() [39/41]

maxon::MATH_HELPER_INSTANTIATE ( ATan  )

◆ MATH_HELPER_INSTANTIATE() [40/41]

maxon::MATH_HELPER_INSTANTIATE ( SafePow  )

◆ MATH_HELPER_INSTANTIATE() [41/41]

maxon::MATH_HELPER_INSTANTIATE ( SafeSqrt  )

◆ MAXON_ENUM_LIST() [57/113]

enum maxon::ANIMBLENDSTATE maxon::MAXON_ENUM_LIST ( ANIMBLENDSTATE  )

◆ MAXON_DECLARATION() [73/89]

maxon::MAXON_DECLARATION ( Class< BlendAnimationRef >  ,
AnimBlendClass  ,
"net.maxon.class.blendanimationref"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.math")   
)

◆ MAXON_REGISTRY() [46/64]

maxon::MAXON_REGISTRY ( BlendFunctionRef  ,
BlendFunctions  ,
"net.maxon.registry.blendfunction"   
)

BlendFunctions offers a registry to extend blend functions e.g. for the BlendAnimationInterface.

◆ ComplexGetReal() [1/2]

static T maxon::ComplexGetReal ( const Complex< T > &  val)
static

Get the real part of a value no matter if this is a Complex or Float value.

Parameters
[in]valinput value
Returns
real value

◆ ComplexGetReal() [2/2]

static T maxon::ComplexGetReal ( const T &  val)
static

Get the real part of a value no matter if this is a Complex or Float value.

Parameters
[in]valinput value
Returns
real value

◆ ComplexGetImag() [1/2]

static T maxon::ComplexGetImag ( const Complex< T > &  val)
static

Get the imaginary part of a value no matter if this is a Complex or Float value. In the latter case the function will return 0.0

Parameters
[in]valinput value
Returns
real value

◆ ComplexGetImag() [2/2]

static T maxon::ComplexGetImag ( const T &  val)
static

Get the imaginary part of a value no matter if this is a Complex or Float value. In the latter case the function will return 0.0

Parameters
[in]valinput value
Returns
real value

◆ ComplexSetReal() [1/2]

static void maxon::ComplexSetReal ( Complex< T1 > &  dst,
const T2 &  val 
)
static

Set the real part of a value no matter if this is a Complex or Float value.

Parameters
[in]dstdestination value
[in]valreal value to be set

◆ ComplexSetReal() [2/2]

static void maxon::ComplexSetReal ( T1 &  dst,
const T2 &  val 
)
static

Set the real part of a value no matter if this is a Complex or Float value.

Parameters
[in]dstdestination value
[in]valreal value to be set

◆ ComplexSetImag() [1/2]

static void maxon::ComplexSetImag ( Complex< T1 > &  dst,
const T2 &  val 
)
static

Set the imaginary part of a value no matter if this is a Complex or Float value. In the latter case the function will do nothing

Parameters
[in]dstdestination value
[in]valimaginary value to be set

◆ ComplexSetImag() [2/2]

static void maxon::ComplexSetImag ( T1 &  dst,
const T2 &  val 
)
static

Set the imaginary part of a value no matter if this is a Complex or Float value. In the latter case the function will do nothing

Parameters
[in]dstdestination value
[in]valimaginary value to be set

◆ MAXON_DATATYPE() [52/73]

maxon::MAXON_DATATYPE ( Complex32  ,
"net.maxon.datatype.complex32"   
)

◆ MAXON_DATATYPE() [53/73]

maxon::MAXON_DATATYPE ( Complex64  ,
"net.maxon.datatype.complex64"   
)

◆ MAXON_ENUM_FLAGS() [26/34]

enum maxon::FFT_FLAGS maxon::MAXON_ENUM_FLAGS ( FFT_FLAGS  )

◆ MAXON_ENUM_FLAGS() [27/34]

enum maxon::FFT_SUPPORT maxon::MAXON_ENUM_FLAGS ( FFT_SUPPORT  )

◆ MAXON_REGISTRY() [47/64]

maxon::MAXON_REGISTRY ( Class< FFTRef >  ,
FFTClasses  ,
"net.maxon.registry.fftclasses"   
)

Registry to register/iterate all available FFT implementations.

◆ MAXON_DATATYPE() [54/73]

maxon::MAXON_DATATYPE ( MatrixNxM32  ,
"net.maxon.datatype.matrixnxm32"   
)

◆ MAXON_DATATYPE() [55/73]

maxon::MAXON_DATATYPE ( MatrixNxM64  ,
"net.maxon.datatype.matrixnxm64"   
)

◆ MAXON_DATATYPE() [56/73]

maxon::MAXON_DATATYPE ( MatrixNxMComplex32  ,
"net.maxon.datatype.matrixnxmcomplex32"   
)

◆ MAXON_DATATYPE() [57/73]

maxon::MAXON_DATATYPE ( MatrixNxMComplex64  ,
"net.maxon.datatype.matrixnxmcomplex64"   
)

◆ TranslateRotationOrder()

ROTATIONORDER maxon::TranslateRotationOrder ( const Id type)

Translate and Id rotation order value into the corresponding enum value.

Parameters
[in]typeThe ordering Id value.
Returns
The matching ROTATIONORDER.

◆ MAXON_DATATYPE() [58/73]

maxon::MAXON_DATATYPE ( PRSMatrix64  ,
"net.maxon.neutron.datatype.psrmatrix"   
)

◆ MAXON_DATATYPE() [59/73]

maxon::MAXON_DATATYPE ( PRSMatrix32  ,
"net.maxon.math.datatype.prsmatrix32"   
)

◆ MAXON_ENUM_LIST() [58/113]

enum maxon::NURBSCURVE_CONTINUITY maxon::MAXON_ENUM_LIST ( NURBSCURVE_CONTINUITY  )

◆ MAXON_IMPLEMENTATION_SIMPLE_REGISTER() [4/5]

maxon::MAXON_IMPLEMENTATION_SIMPLE_REGISTER ( NURBSCurveWithContinuity< D >  )

◆ MAXON_ENUM_LIST() [59/113]

enum maxon::NURBSCURVE_KNOTMODE maxon::MAXON_ENUM_LIST ( NURBSCURVE_KNOTMODE  )

◆ MAXON_IMPLEMENTATION_SIMPLE_REGISTER() [5/5]

maxon::MAXON_IMPLEMENTATION_SIMPLE_REGISTER ( NURBSCurve< D >  )

◆ MAXON_DATATYPE() [60/73]

maxon::MAXON_DATATYPE ( Quaternion32  ,
"net.maxon.datatype.quaternion32"   
)

◆ MAXON_DATATYPE() [61/73]

maxon::MAXON_DATATYPE ( Quaternion64  ,
"net.maxon.datatype.quaternion64"   
)

◆ MatrixConvert()

void maxon::MatrixConvert ( SquareMatrix4d dest,
const Matrix src 
)

◆ MAXON_ENUM_LIST() [60/113]

enum maxon::PRIMITIVETYPE maxon::MAXON_ENUM_LIST ( PRIMITIVETYPE  )

◆ MAXON_DECLARATION() [74/89]

maxon::MAXON_DECLARATION ( Class< DistanceQueryRef >  ,
DistanceCalculator  ,
"net.maxon.geom.interface.distancequery.distancecalculator"   
)

◆ MAXON_REGISTRY() [48/64]

maxon::MAXON_REGISTRY ( CustomDataTagClass  ,
CustomDataTagClasses  ,
"net.maxon.mesh_misc.registry.customdatatagclasses"   
)

◆ MAXON_REGISTRY() [49/64]

maxon::MAXON_REGISTRY ( Class< CustomDataTagDisplayRef >  ,
CustomDataTagDisplayClasses  ,
"net.maxon.mesh_misc.registry.customdatatagdisplayclasses"   
)

◆ MAXON_DATATYPE() [62/73]

maxon::MAXON_DATATYPE ( MeshAttribute  ,
"net.maxon.mesh_misc.datatype.meshattribute"   
)

◆ MAXON_DATATYPE() [63/73]

maxon::MAXON_DATATYPE ( PolygroupInformation  ,
"net.maxon.meshattribute.gozpolyinformation"   
)

Declaration of a new DataType. This will be store inside the new mesh attribute

◆ MAXON_MESHATTRIBUTE()

maxon::MAXON_MESHATTRIBUTE ( PolygroupInformation  ,
POLYGROUP   
)

Declaration of the new MeshAttribute.

◆ MAXON_DATATYPE() [64/73]

maxon::MAXON_DATATYPE ( POLYGROUP_MESHATTRIBUTE  ,
"net.maxon.meshattribute.gozpolygroup"   
)

Declaration of the new DataTape for the mesh attribute.

◆ MAXON_DECLARATION() [75/89]

maxon::MAXON_DECLARATION ( Class< VoxelizationRef >  ,
PolyVoxelization  ,
"net.maxon.geom.interface.voxelization.polyvoxelization"   
)

◆ MAXON_ENUM_FLAGS() [28/34]

enum maxon::CORENODE_PORT_FLAGS maxon::MAXON_ENUM_FLAGS ( CORENODE_PORT_FLAGS  )

◆ MAXON_ENUM_LIST() [61/113]

enum maxon::PORT_DIR Int maxon::MAXON_ENUM_LIST ( PORT_DIR  )

◆ operator++()

PORT_DIR& maxon::operator++ ( PORT_DIR dir)

◆ Reverse() [5/5]

PORT_DIR maxon::Reverse ( PORT_DIR  dir)

Returns the reverse of the given direction. PORT_DIR::INPUT becomes PORT_DIR::OUTPUT and vice versa.

Parameters
[in]dirA direction.
Returns
The reverse of dir.

◆ MAXON_REGISTRY() [50/64]

maxon::MAXON_REGISTRY ( IconProvider  ,
IconProviders  ,
"net.maxon.registry.iconproviders"   
)

Registry for IconProvider, see there. You have to register your own provider if you want to use own icons with the IconProvider mechanism.

◆ GetUrlFromIconProviders()

Result<Url> maxon::GetUrlFromIconProviders ( const CString iconId)

◆ MAXON_ENUM_LIST() [62/113]

enum maxon::IOFORMAT maxon::MAXON_ENUM_LIST ( IOFORMAT  )

◆ ReadDocument() [1/6]

std::enable_if<GetCollectionKind<T>::value == COLLECTION_KIND::ARRAY, Result<void> >::type maxon::ReadDocument ( const Url url,
const Id id,
T &  object,
const DataDictionary &  dict = DataDictionary() 
)

◆ ReadDocument() [2/6]

std::enable_if<GetCollectionKind<T>::value != COLLECTION_KIND::ARRAY && !STD_IS_REPLACEMENT(same, T, Data), Result<void> >::type maxon::ReadDocument ( const Url url,
const Id id,
T &  object,
const DataDictionary &  dict = DataDictionary() 
)

◆ ReadDocument() [3/6]

std::enable_if<STD_IS_REPLACEMENT(same, T, Data), Result<void> >::type maxon::ReadDocument ( const Url url,
const Id id,
T &  object,
const DataDictionary &  dict = DataDictionary() 
)

◆ ReadDocument() [4/6]

std::enable_if<GetCollectionKind<T>::value == COLLECTION_KIND::ARRAY, Result<void> >::type maxon::ReadDocument ( UrlOrInputStream &&  urlOrStream,
const Id id,
T &  object,
IOFORMAT  format = IOFORMAT::DEFAULT,
const DataDictionary &  dict = DataDictionary() 
)

◆ ReadDocument() [5/6]

std::enable_if<GetCollectionKind<T>::value != COLLECTION_KIND::ARRAY && !STD_IS_REPLACEMENT(same, T, Data), Result<void> >::type maxon::ReadDocument ( UrlOrInputStream &&  urlOrStream,
const Id id,
T &  object,
IOFORMAT  format = IOFORMAT::DEFAULT,
const DataDictionary &  dict = DataDictionary() 
)

◆ ReadDocument() [6/6]

std::enable_if<STD_IS_REPLACEMENT(same, T, Data), Result<void> >::type maxon::ReadDocument ( UrlOrInputStream &&  urlOrStream,
const Id id,
T &  object,
IOFORMAT  format = IOFORMAT::DEFAULT,
const DataDictionary &  dict = DataDictionary() 
)

◆ WriteDocument() [1/4]

Result<void> maxon::WriteDocument ( const Url url,
OPENSTREAMFLAGS  flags,
const Id id,
const T &  object,
IOFORMAT  format = IOFORMAT::DEFAULT,
const DataDictionary &  dict = DataDictionary() 
)

◆ WriteDocument() [2/4]

std::enable_if<GetCollectionKind<T>::value == COLLECTION_KIND::ARRAY, Result<void> >::type maxon::WriteDocument ( const OutputStreamRef &  stream,
const Id id,
const T &  object,
IOFORMAT  format = IOFORMAT::DEFAULT,
const DataDictionary &  dict = DataDictionary() 
)

◆ WriteDocument() [3/4]

std::enable_if<STD_IS_REPLACEMENT(same, T, Data), Result<void> >::type maxon::WriteDocument ( const OutputStreamRef &  stream,
const Id id,
const T &  object,
IOFORMAT  format = IOFORMAT::DEFAULT,
const DataDictionary &  dict = DataDictionary() 
)

◆ WriteDocument() [4/4]

std::enable_if<GetCollectionKind<T>::value != COLLECTION_KIND::ARRAY && !STD_IS_REPLACEMENT(same, T, Data), Result<void> >::type maxon::WriteDocument ( const OutputStreamRef &  stream,
const Id id,
const T &  object,
IOFORMAT  format = IOFORMAT::DEFAULT,
const DataDictionary &  dict = DataDictionary() 
)

◆ MAXON_ENUM_LIST() [63/113]

enum maxon::PROFILER_POINT_TYPE maxon::MAXON_ENUM_LIST ( PROFILER_POINT_TYPE  )

◆ MAXON_ENUM_LIST() [64/113]

enum maxon::PROFILER_STATE maxon::MAXON_ENUM_LIST ( PROFILER_STATE  )

◆ MAXON_ENUM_LIST() [65/113]

enum maxon::PROFILER_CLOCK_MODE maxon::MAXON_ENUM_LIST ( PROFILER_CLOCK_MODE  )

◆ MAXON_DECLARATION() [76/89]

maxon::MAXON_DECLARATION ( maxon::Profiler ,
ProfilerInstance  ,
"net.maxon.profiler"   
)

◆ MAXON_ATTRIBUTE() [13/16]

maxon::MAXON_ATTRIBUTE ( UniversalDateTime  ,
DATE_FILECREATED  ,
"net.maxon.ramdisk.date.created"   
)

◆ MAXON_ATTRIBUTE() [14/16]

maxon::MAXON_ATTRIBUTE ( UniversalDateTime  ,
DATE_FILEMODIFIED  ,
"net.maxon.ramdisk.date.modified"   
)

◆ MAXON_ATTRIBUTE() [15/16]

maxon::MAXON_ATTRIBUTE ( UniversalDateTime  ,
DATE_FILEACCESSED  ,
"net.maxon.ramdisk.date.accessed"   
)

◆ Ref() [1/2]

ReferenceWrapper<TYPE> maxon::Ref ( TYPE &  val)
noexcept

Constructs a ReferenceWrapper instance from a reference type.

◆ Ref() [2/2]

void maxon::Ref ( TYPE &&  val)
delete

◆ CRef() [1/2]

ReferenceWrapper<const TYPE> maxon::CRef ( TYPE &  val)
noexcept

Constructs a const ReferenceWrapper instance from a const reference type.

◆ CRef() [2/2]

void maxon::CRef ( TYPE &&  val)
delete

◆ MAXON_ENUM_LIST() [66/113]

enum maxon::SELECTION_MODE UChar maxon::MAXON_ENUM_LIST ( SELECTION_MODE  )

◆ MAXON_ENUM_FLAGS() [29/34]

enum maxon::SELECTION_STATUS UChar maxon::MAXON_ENUM_FLAGS ( SELECTION_STATUS  )

◆ SCCCheckOutFile()

Result<void> maxon::SCCCheckOutFile ( const Url url,
Bool  outputError 
)

◆ SCCAddFile()

Result<void> maxon::SCCAddFile ( const Url url,
Bool  outputError 
)

◆ MAXON_REGISTRY() [51/64]

maxon::MAXON_REGISTRY ( SubData  ,
SubDatas  ,
"net.maxon.registry.subdatas"   
)

◆ MAXON_REGISTRY() [52/64]

maxon::MAXON_REGISTRY ( SubDataOperation  ,
SubDataOperations  ,
"net.maxon.registry.subdataoperations"   
)

◆ MAXON_REGISTRY() [53/64]

maxon::MAXON_REGISTRY ( Class< ConvexDecompositionRef >  ,
ConvexDecompositionClasses  ,
"net.maxon.registry.convexdecompositionclasses"   
)

◆ ClampQuadIndex()

constexpr MAXON_ATTRIBUTE_FORCE_INLINE U maxon::ClampQuadIndex ( const T  index)
constexpr

A more efficient way to clamp an index in a quad using bit masking, because we know the size of the quad is 4 = 2^2.

Parameters
[in]indexA vertex index of a quad in the range [0, 3].
Returns
A clamped index of a quad in the range [0, 3].

◆ FindDirectedVertexIndexInQuad()

Int32 maxon::FindDirectedVertexIndexInQuad ( const Block< const Int32 polyVertices,
const EdgePair  edgePair 
)
Parameters
[in]polyVerticesPolygon vertices.
[in]edgePairAn edge pair to find the start index of given the direction of vertices in the polygon.
Returns
The index of the start vertex in the quad.

◆ FindPrevEdgeInQuad()

EdgePair maxon::FindPrevEdgeInQuad ( const Block< const Int32 polyVertices,
const EdgePair  edgePair 
)

Returns the previous edge in the quad.

Parameters
[in]polyVerticesPolygon vertices.
[in]edgePairAn input edge pair to get the previous edge pair for.
Returns
The previous edge pair in the quad.

◆ FindNextEdgeInQuad()

EdgePair maxon::FindNextEdgeInQuad ( const Block< const Int32 polyVertices,
const EdgePair  edgePair 
)

Returns the next edge in the quad.

Parameters
[in]polyVerticesPolygon vertices.
[in]edgePairAn input edge pair to get the next edge pair for.
Returns
The next edge pair in the quad.

◆ FindOppositeDirectedEdgeInQuad()

EdgePair maxon::FindOppositeDirectedEdgeInQuad ( const Block< const Int32 polyVertices,
const EdgePair  edgePair 
)
Parameters
[in]polyVerticesPolygon vertices.
[in]edgePairAn input edge pair to get the opposite edge pair of.
Returns
The opposite edge pair in the quad.

◆ MAXON_ENUM_LIST() [67/113]

enum maxon::GEOMETRY_TEST_EXACT maxon::MAXON_ENUM_LIST ( GEOMETRY_TEST_EXACT  )

◆ MAXON_ENUM_LIST() [68/113]

enum maxon::LOOP_OVERLAP_STATE maxon::MAXON_ENUM_LIST ( LOOP_OVERLAP_STATE  )

◆ MAXON_REGISTRY() [54/64]

maxon::MAXON_REGISTRY ( InterpolateType  ,
InterpolateTypes  ,
"net.maxon.geometry.registry.interpolation.types"   
)

Registration of registry for different types of MeshMapClass.

◆ MAXON_DATATYPE() [65/73]

maxon::MAXON_DATATYPE ( SimplePolygon  ,
"net.maxon.geom.simplepolygon"   
)

◆ MAXON_DATATYPE() [66/73]

maxon::MAXON_DATATYPE ( UVWPolygon  ,
"net.maxon.geom.uvwpolygon"   
)

◆ GetPredecessor()

INDEXTYPE maxon::GetPredecessor ( INDEXTYPE  index,
COUNT  vertexCount 
)

< 2d Tangent basic data type

Calculates the predecessor index of a closed vertices loop.

Parameters
[in]indexA vertex index in the loop. Must be in the range [0..vertexCount-1].
[in]vertexCountThe number of vertices in a closed loop.
Returns
The decremented index value. If the lower limit is hit vertexCount - 1 is returned.

◆ GetSuccessor()

INDEXTYPE maxon::GetSuccessor ( INDEXTYPE  index,
COUNT  vertexCount 
)

Calculates the successor index of a closed vertices loop.

Parameters
[in]indexA vertex index in the loop. Must be in the range [0..vertexCount-1].
[in]vertexCountThe number of vertices in a closed loop.
Returns
The incremented index value. If the lower limit is hit vertexCount - 1 is returned.

◆ MAXON_ENUM_LIST() [69/113]

enum maxon::HTTPCODE maxon::MAXON_ENUM_LIST ( HTTPCODE  )

◆ MAXON_ENUM_LIST() [70/113]

enum maxon::SOCKETMODE maxon::MAXON_ENUM_LIST ( SOCKETMODE  )

◆ MAXON_ENUM_LIST() [71/113]

enum maxon::CONNECTIONMODE maxon::MAXON_ENUM_LIST ( CONNECTIONMODE  )

◆ MAXON_ENUM_LIST() [72/113]

enum maxon::CONNECTIONTYPE maxon::MAXON_ENUM_LIST ( CONNECTIONTYPE  )

◆ MAXON_DECLARATION_STRINGENCODING() [1/2]

maxon::MAXON_DECLARATION_STRINGENCODING ( "html"  ,
Html  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.network")   
)

HTML

  • encodes characters from Utf32Char to UChar
  • decodes characters from UChar to Utf32Char

Details:

  • characters in the range 0..127 are encoded as single byte values
  • characters above127 are encoded into a sequence of bytes.
  • for special characters a character entity table is used to map the characters to a byte sequence see http://www.w3.org/TR/html5/syntax.html#named-character-references. For example $ is converted to &dollar;
  • Any other character is encoded by a sequence of characters with &#xhhhh; where each hhhh is the hex value representing the character in Unicode space.
  • The decoder reads any of these possible HTML hex value formats (d=decimal digit, h=hex digit):
    • &#d;
    • &#dd;
    • &#ddd;
    • &#dddd;
    • &#xh;
    • &#xhh;
    • &#xhhh;
    • &#xhhhh;
  • Also any known character entity name is decoded as well

Errors:
Returns an error if unkown byte codes outside the valid range are used.
HTML forbids the use of the characters with Universal Character Set/Unicode code points:

◆ MAXON_DECLARATION_STRINGENCODING() [2/2]

maxon::MAXON_DECLARATION_STRINGENCODING ( "punycode"  ,
Punycode  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.network")   
)

◆ MAXON_ENUM_LIST() [73/113]

enum maxon::PROTOCOL maxon::MAXON_ENUM_LIST ( PROTOCOL  )

◆ MAXON_ENUM_LIST() [74/113]

◆ MAXON_ENUM_LIST() [75/113]

◆ MAXON_DECLARATION() [77/89]

maxon::MAXON_DECLARATION ( Class< SSHNetworkConnectionRef >  ,
NetworkConnectionSSHClass  ,
"net.maxon.class.networkconnectionssh"   
)

◆ MAXON_ENUM_LIST() [76/113]

enum maxon::SSLSOCKETTYPE maxon::MAXON_ENUM_LIST ( SSLSOCKETTYPE  )

◆ MAXON_ENUM_LIST() [77/113]

enum maxon::SSLPROTOCOLVERSION maxon::MAXON_ENUM_LIST ( SSLPROTOCOLVERSION  )

◆ MAXON_ENUM_FLAGS() [30/34]

enum maxon::SSLCERTREQUIREMENTS maxon::MAXON_ENUM_FLAGS ( SSLCERTREQUIREMENTS  )

◆ MAXON_ENUM_LIST() [78/113]

enum maxon::SSLFILETYPE maxon::MAXON_ENUM_LIST ( SSLFILETYPE  )

◆ MAXON_DECLARATION() [78/89]

maxon::MAXON_DECLARATION ( Class< SSLNetworkConnectionRef >  ,
NetworkConnectionSSLClass  ,
"net.maxon.class.networkconnectionssl"   
)

◆ MAXON_ENUM_LIST() [79/113]

enum maxon::OAUTHSIGNATUREMETHOD maxon::MAXON_ENUM_LIST ( OAUTHSIGNATUREMETHOD  )

◆ MAXON_ENUM_LIST() [80/113]

enum maxon::OAUTHHTTPMETHOD maxon::MAXON_ENUM_LIST ( OAUTHHTTPMETHOD  )

◆ MAXON_ENUM_LIST() [81/113]

enum maxon::OAUTHERRORCODE maxon::MAXON_ENUM_LIST ( OAUTHERRORCODE  )

◆ MAXON_DECLARATION() [79/89]

maxon::MAXON_DECLARATION ( Class< UrlRedirectRef >  ,
UrlRedirectClass  ,
"net.maxon.class.urlredirectclass"   
)

◆ operator==() [7/8]

Bool maxon::operator== ( const ResourceIdentifier lhs,
const ResourceIdentifier rhs 
)

◆ operator!=() [6/7]

Bool maxon::operator!= ( const ResourceIdentifier lhs,
const ResourceIdentifier rhs 
)

◆ operator==() [8/8]

Bool maxon::operator== ( const ServiceProviderDetails lhs,
const ServiceProviderDetails rhs 
)

◆ operator!=() [7/7]

Bool maxon::operator!= ( const ServiceProviderDetails lhs,
const ServiceProviderDetails rhs 
)

◆ MAXON_ENUM_LIST() [82/113]

enum maxon::HTTPMETHOD maxon::MAXON_ENUM_LIST ( HTTPMETHOD  )

◆ ConvertFromUnicodeToUtf8Url()

CString maxon::ConvertFromUnicodeToUtf8Url ( const StringEncodingRef &  urlEncoding,
const String src 
)

◆ MAXON_DECLARATION() [80/89]

maxon::MAXON_DECLARATION ( ComponentDescriptor  ,
CombinerHttpCodeComponents  ,
"net.maxon.component.combinerhttpcodecomponents"   
)

Implementation of CombinerInterface. Using this combiner ensures that all subscribers are called. The result is combined by an OR operation.

◆ MAXON_ENUM_LIST() [83/113]

enum maxon::HTTPREQUESTTYPE maxon::MAXON_ENUM_LIST ( HTTPREQUESTTYPE  )

◆ MAXON_DECLARATION() [81/89]

maxon::MAXON_DECLARATION ( Class< NetworkIpHandlerRef >  ,
NetworkIpHandlerClass  ,
"net.maxon.class.networkiphandler"   
)

object definitions

◆ MAXON_DECLARATION() [82/89]

maxon::MAXON_DECLARATION ( Class< NetworkHttpHandlerRef >  ,
NetworkHttpHandlerClass  ,
"net.maxon.class.networkhttphandler"   
)

◆ MAXON_DECLARATION() [83/89]

maxon::MAXON_DECLARATION ( Class< NetworkWebServerRef >  ,
NetworkWebServerClass  ,
"net.maxon.class.networkwebserver"   
)

◆ MAXON_ENUM_LIST() [84/113]

enum maxon::WEBSOCKETSTATE maxon::MAXON_ENUM_LIST ( WEBSOCKETSTATE  )

◆ MAXON_ENUM_LIST() [85/113]

enum maxon::WEBSOCKETTYPE maxon::MAXON_ENUM_LIST ( WEBSOCKETTYPE  )

◆ MAXON_ENUM_LIST() [86/113]

enum maxon::WEBSOCKET_OPCODE UChar maxon::MAXON_ENUM_LIST ( WEBSOCKET_OPCODE  )

◆ MAXON_DECLARATION() [84/89]

maxon::MAXON_DECLARATION ( Class< NetworkWebSocketConnectionRef >  ,
NetworkWebSocketConnectionClass  ,
"net.maxon.class.networkwebsocketconnection"   
)

◆ MAXON_DECLARATION() [85/89]

maxon::MAXON_DECLARATION ( Class< NetworkWebSocketSignalRef >  ,
NetworkWebSocketSignalClass  ,
"net.maxon.class.networkwebsocketsignal"   
)

◆ MAXON_DECLARATION() [86/89]

maxon::MAXON_DECLARATION ( Class< NetworkWebSocketServerRef >  ,
NetworkWebSocketServerClass  ,
"net.maxon.class.networkwebsocketserver"   
)

◆ MAXON_DECLARATION() [87/89]

maxon::MAXON_DECLARATION ( Class< NetworkWebSocketClientConnectionRef >  ,
NetworkWebSocketClientConnectionClass  ,
"net.maxon.class.networkwebsocketclientconnection"   
)

◆ MAXON_ENUM_FLAGS() [31/34]

enum maxon::ZEROCONFACTION maxon::MAXON_ENUM_FLAGS ( ZEROCONFACTION  )

◆ MAXON_ENUM_LIST() [87/113]

enum maxon::ZEROCONFMACHINESTATE maxon::MAXON_ENUM_LIST ( ZEROCONFMACHINESTATE  )

◆ MAXON_ENUM_LIST() [88/113]

enum maxon::ZEROCONFERROR maxon::MAXON_ENUM_LIST ( ZEROCONFERROR  )

◆ MAXON_ATTRIBUTE() [16/16]

maxon::MAXON_ATTRIBUTE ( void  ,
AssetCategoryNodeContext  ,
"net.maxon.asset.category.nodecontext"   
)

Use this to set category or search by category.

CategoryAssetInterface::SetAssetCategory(asset, AssetCategoryNodeContext) iferr_return;
static MAXON_METHOD Result< void > SetAssetCategory(const AssetDescription &asset, const Id &category)

◆ MAXON_ENUM_LIST() [89/113]

enum maxon::NIMBUS_PATH maxon::MAXON_ENUM_LIST ( NIMBUS_PATH  )

◆ MAXON_DATATYPE() [67/73]

maxon::MAXON_DATATYPE ( WeakNimbusBaseRef  ,
"net.maxon.datatype.weaknimbusref"   
)

◆ MAXON_REGISTRY() [55/64]

maxon::MAXON_REGISTRY ( NimbusContextGetter  ,
NimbusContextGetters  ,
"net.maxon.registry.nimbuscontextgetters"   
)

This registry collects delegates used by NimbusBaseInterface::UpdateGlobalContext. For any nested port of the GlobalContext port, the port's value is set up by the delegate registered under the id of the port.

◆ MAXON_ENUM_LIST() [90/113]

enum maxon::PyStringEncodings maxon::MAXON_ENUM_LIST ( PyStringEncodings  )

◆ MAXON_ENUM_LIST() [91/113]

enum maxon::OWNERSHIP maxon::MAXON_ENUM_LIST ( OWNERSHIP  )

◆ operator/()

◆ MAXON_REGISTRY() [56/64]

maxon::MAXON_REGISTRY ( Class< PyModuleRef >  ,
PyModules  ,
"net.maxon.python.registry.pymodules"   
)

◆ MAXON_REGISTRY() [57/64]

maxon::MAXON_REGISTRY ( Class< LibraryRef >  ,
CPythonLibs  ,
"net.maxon.python.registry.cpythonlibs"   
)

◆ PrivateExtractCPythonLibrary3()

py::CPythonLibraryRef maxon::PrivateExtractCPythonLibrary3 ( py::NativePyObject self)

◆ _Python3Output() [1/3]

void maxon::_Python3Output ( maxon::TARGETAUDIENCE  audience,
const Char str,
Int  line,
const Char file,
maxon::WRITEMETA  meta = maxon::WRITEMETA::DEFAULT 
)

◆ _Python3Output() [2/3]

void maxon::_Python3Output ( maxon::TARGETAUDIENCE  audience,
const maxon::String str,
Int  line,
const Char file 
)

◆ _Python3Output() [3/3]

void maxon::_Python3Output ( maxon::TARGETAUDIENCE  audience,
maxon::StringProxy proxy,
Int  line,
const Char file 
)

◆ PrivateRegisterCPythonFunc()

maxon::Error maxon::PrivateRegisterCPythonFunc ( const Char name,
py::NativePyCFunctionWithKeywords  underlyingFunc3,
BaseArray< NativePyCFunctionTable > &  functions3 
)

◆ PrivateCPyRefDiagnosticOutput()

void maxon::PrivateCPyRefDiagnosticOutput ( MAXON_SOURCE_LOCATION_DECLARATION  ,
const Char refName,
const py::CPyRef ref 
)

◆ GetSymbol()

static auto maxon::GetSymbol ( const DllRef &  dll,
const CString symbol 
)
static

◆ MAXON_ENUM_LIST() [92/113]

enum maxon::Errno int maxon::MAXON_ENUM_LIST ( Errno  )

◆ MAXON_ENUM_LIST() [93/113]

enum maxon::CONTAINS int maxon::MAXON_ENUM_LIST ( CONTAINS  )

◆ MAXON_ENUM_FLAGS() [32/34]

enum maxon::VMSETTINGS maxon::MAXON_ENUM_FLAGS ( VMSETTINGS  )

◆ MAXON_ENUM_LIST() [94/113]

enum maxon::VMINITSETTINGS maxon::MAXON_ENUM_LIST ( VMINITSETTINGS  )

◆ MAXON_ENUM_LIST() [95/113]

enum maxon::ERRORHANDLING maxon::MAXON_ENUM_LIST ( ERRORHANDLING  )

◆ DiagnosticOutputFlags()

void maxon::DiagnosticOutputFlags ( EntityBase::FLAGS  flags)

◆ DiagnosticOutputValueKind()

void maxon::DiagnosticOutputValueKind ( const DataType dt)

◆ MAXON_ENUM_LIST() [96/113]

enum maxon::DEFAULTRUNTIME maxon::MAXON_ENUM_LIST ( DEFAULTRUNTIME  )

◆ MAXON_REGISTRY() [58/64]

maxon::MAXON_REGISTRY ( Class< VirtualMachineRef >  ,
VirtualMachines  ,
"net.maxon.python.registry.virtualmachines"   
)

◆ MAXON_REGISTRY() [59/64]

maxon::MAXON_REGISTRY ( VmDebuggerConnectionRef  ,
VmDebuggerConnections  ,
"net.maxon.python.registry.vmdebuggerconnections"   
)

◆ MAXON_DECLARATION() [88/89]

maxon::MAXON_DECLARATION ( Class< VirtualMachineScopeRef >  ,
CPythonScope  ,
"net.maxon.python.virtualmachine.scope"   
)

◆ MAXON_REGISTRY() [60/64]

maxon::MAXON_REGISTRY ( VirtualMachineRef  ,
PythonVms  ,
"net.maxon.python.virtualmachines"   
)

◆ MAXON_REGISTRY() [61/64]

maxon::MAXON_REGISTRY ( Class< FilterRef >  ,
FilterClasses  ,
"net.maxon.renderfilter.registry.filterclasses"   
)

◆ MAXON_REGISTRY() [62/64]

maxon::MAXON_REGISTRY ( Class< FilterCommandQueueRef >  ,
FilterCommandQueueClasses  ,
"net.maxon.renderfilter.registry.filtercommandqueueclasses"   
)

◆ MAXON_REGISTRY() [63/64]

maxon::MAXON_REGISTRY ( Class< FilterContextRef >  ,
FilterContextClasses  ,
"net.maxon.renderfilter.registry.filtercontextclasses"   
)

◆ MAXON_REGISTRY() [64/64]

maxon::MAXON_REGISTRY ( Class< FilterImageRef >  ,
FilterImageClasses  ,
"net.maxon.renderfilter.registry.filterimageclasses"   
)

◆ MAXON_ENUM_LIST() [97/113]

enum maxon::LINEXECUTION maxon::MAXON_ENUM_LIST ( LINEXECUTION  )

◆ ToBlock()

Block<const Byte> maxon::ToBlock ( CFDataRef  ref)

◆ GetCustomCFAllocator()

CFAllocatorRef maxon::GetCustomCFAllocator ( )

Returns a custom CFAllocator which only supports dealloc via DeleteMem.

Returns
Custom CFAllocator.

◆ GetSystemColorSpace()

CGColorSpaceRef maxon::GetSystemColorSpace ( )

◆ GetColorSpaceSRGB()

CGColorSpaceRef maxon::GetColorSpaceSRGB ( )

◆ CGImageToARGB()

Result<void> maxon::CGImageToARGB ( CGImageRef  image,
Int  width,
Int  height,
void *  buf 
)

◆ ToCFString() [1/2]

CFStrongRef<CFStringRef> maxon::ToCFString ( const String in)

Converts a String to CFStringRef.

Parameters
[in]inString object.
Returns
CFStrongRef (can contain nullptr).

◆ ToCFString() [2/2]

CFStrongRef<CFStringRef> maxon::ToCFString ( const CString in)

Converts a CString to CFStringRef.

Parameters
[in]inCString object.
Returns
CFStrongRef (can contain nullptr).

◆ CFToString()

String maxon::CFToString ( const CFStringRef  in)

Converts a CFStringRef to String.

Parameters
[in]inCFStringRef (can be nullptr).
Returns
String object.

◆ CreateCFString()

CFStringRef maxon::CreateCFString ( const String in)

◆ ToCFURL()

Result<CFStrongRef<CFURLRef> > maxon::ToCFURL ( const Url fn)

Converts a Url to CFURLRef.

Parameters
[in]fnUrl object.
Returns
CFURLRef (can be nullptr). Make sure to delete CfRelease(cfUrl) to free the object.

◆ CFURLToUrl()

Result<Url> maxon::CFURLToUrl ( const CFURLRef  fn)

◆ GetPreferencesPath()

Result<Url> maxon::GetPreferencesPath ( Bool  localUser)

◆ GetPreferencesPathAsChar()

const Char* maxon::GetPreferencesPathAsChar ( Bool  localUser)

◆ GetApplicationSupportPath()

Result<Url> maxon::GetApplicationSupportPath ( Bool  localUser)

◆ GetSysCtlString() [1/3]

Bool maxon::GetSysCtlString ( const char *  what,
const Block< Char > &  out_str 
)

◆ GetSysCtlString() [2/3]

Bool maxon::GetSysCtlString ( const char *  what,
Int32 out 
)

◆ GetSysCtlString() [3/3]

Bool maxon::GetSysCtlString ( const char *  what,
UInt64 out 
)

◆ MAXON_PREPROCESSOR_CONDITION()

maxon::MAXON_PREPROCESSOR_CONDITION ( defined(MAXON_TARGET_WINDOWS)  )

◆ MAXON_ENUM_LIST() [98/113]

enum maxon::GRIDTYPE maxon::MAXON_ENUM_LIST ( GRIDTYPE  )

◆ MAXON_ENUM_LIST() [99/113]

enum maxon::GRIDCLASS maxon::MAXON_ENUM_LIST ( GRIDCLASS  )

◆ MAXON_ENUM_LIST() [100/113]

enum maxon::VECTORGRIDTYPE maxon::MAXON_ENUM_LIST ( VECTORGRIDTYPE  )

◆ MAXON_ENUM_LIST() [101/113]

enum maxon::NANOVDBPRECISION maxon::MAXON_ENUM_LIST ( NANOVDBPRECISION  )

◆ MAXON_DECLARATION() [89/89]

maxon::MAXON_DECLARATION ( Class< Volume >  ,
VOLUME  ,
"net.maxon.volume.class.volume"   
)

◆ MAXON_ENUM_LIST() [102/113]

enum maxon::VOLUMESAMPLER maxon::MAXON_ENUM_LIST ( VOLUMESAMPLER  ,
"net.maxon.volume.datatype.enum.volumesampler"   
)

◆ MAXON_DATATYPE() [68/73]

maxon::MAXON_DATATYPE ( GridAccessorBase  ,
"net.maxon.volume.datatype.gridaccessorbaseref"   
)

◆ MAXON_ENUM_LIST() [103/113]

enum maxon::ITERATORTYPE maxon::MAXON_ENUM_LIST ( ITERATORTYPE  )

◆ MAXON_ENUM_LIST() [104/113]

enum maxon::TREEVOXELLEVEL maxon::MAXON_ENUM_LIST ( TREEVOXELLEVEL  )

◆ MAXON_ENUM_LIST() [105/113]

enum maxon::VOLUME_RAY_TYPE maxon::MAXON_ENUM_LIST ( VOLUME_RAY_TYPE  ,
"net.maxon.volume.datatype.enum.raytype"   
)

◆ MAXON_DATATYPE() [69/73]

maxon::MAXON_DATATYPE ( VolumeRayIntersectorBase  ,
"net.maxon.volume.datatype.volumerayintersectorbaseref"   
)

◆ MAXON_ENUM_FLAGS() [33/34]

enum maxon::POLYGONCONVERSIONFLAGS maxon::MAXON_ENUM_FLAGS ( POLYGONCONVERSIONFLAGS  ,
"net.maxon.volume.datatype.enum.polygonconversionflags"   
)

◆ MAXON_ENUM_LIST() [106/113]

enum maxon::MIXVECTORTYPE maxon::MAXON_ENUM_LIST ( MIXVECTORTYPE  ,
"net.maxon.volume.datatype.enum.mixvectortype"   
)

◆ MAXON_ENUM_LIST() [107/113]

enum maxon::SDFFILTERTYPE maxon::MAXON_ENUM_LIST ( SDFFILTERTYPE  ,
"net.maxon.volume.datatype.enum.sdffiltertype"   
)

◆ MAXON_ENUM_LIST() [108/113]

enum maxon::FILTERTYPE maxon::MAXON_ENUM_LIST ( FILTERTYPE  ,
"net.maxon.volume.datatype.enum.filtertype"   
)

◆ MAXON_ENUM_LIST() [109/113]

enum maxon::VECTORFILTERTYPE maxon::MAXON_ENUM_LIST ( VECTORFILTERTYPE  ,
"net.maxon.volume.datatype.enum.vectorfiltertype"   
)

◆ MAXON_ENUM_LIST() [110/113]

enum maxon::FILTERACCURACY maxon::MAXON_ENUM_LIST ( FILTERACCURACY  ,
"net.maxon.volume.datatype.enum.filteraccuracy"   
)

◆ MAXON_ENUM_LIST() [111/113]

enum maxon::BOOLTYPE maxon::MAXON_ENUM_LIST ( BOOLTYPE  )

◆ MAXON_ENUM_LIST() [112/113]

enum maxon::MIXTYPE maxon::MAXON_ENUM_LIST ( MIXTYPE  )

◆ MAXON_DATATYPE() [70/73]

maxon::MAXON_DATATYPE ( SDFFilterSettings  ,
"net.maxon.volume.datatype.sdffiltersettings"   
)

◆ MAXON_DATATYPE() [71/73]

maxon::MAXON_DATATYPE ( FilterSettings  ,
"net.maxon.volume.datatype.filtersettings"   
)

◆ MAXON_ENUM_LIST() [113/113]

enum maxon::RESAMPLEINTERPOLATIONTYPE maxon::MAXON_ENUM_LIST ( RESAMPLEINTERPOLATIONTYPE  ,
"net.maxon.volume.datatype.enum.resampleinterpolationtype"   
)

◆ MAXON_ENUM_FLAGS() [34/34]

enum maxon::FIELDLAYER_FLAG maxon::MAXON_ENUM_FLAGS ( FIELDLAYER_FLAG  )

◆ MAXON_DATATYPE() [72/73]

maxon::MAXON_DATATYPE ( FieldSampleData  ,
"net.maxon.volume.datatype.fieldsampledata"   
)

◆ MAXON_DATATYPE() [73/73]

maxon::MAXON_DATATYPE ( VolumeConversionPolygon  ,
"net.maxon.volume.datatype.volumeconversionpolygon"   
)

Variable Documentation

◆ URLSCHEME_ASSET

constexpr LiteralId URLSCHEME_ASSET
constexpr

Scheme identifier for asset references as used by Asset API data structures.

The same asset could be referenced by the URLs "asset:///file_37cd8c8dadea1a6a~.c4d" and "asset:///file_37cd8c8dadea1a6a~.c4d?name=SDK Cube&db=sdkdatabase.db", where the optional parameters are only used in error messages when the asset URL does not resolve. Both URLs can be used to reference the asset.

See also
UrlScheme

◆ URLSCHEME_ASSETDB

constexpr LiteralId URLSCHEME_ASSETDB
constexpr

Scheme identifier for human readable asset references as shown to the user in GUIs.

This scheme is never used to store references. The location of an asset is unpacked into its asset category relations, e.g., asset:///file_37cd8c8dadea1a6a~.c4d -> assetdb:///tex/Surfaces/Dirt Scratches & Smudges/RustPaint0291_M.jpg.

See also
UrlScheme

◆ URLSCHEME_META

constexpr LiteralId URLSCHEME_META
constexpr

Scheme identifier for relative file links to the metadata of an asset in a asset repository.

See also
UrlScheme

◆ URLSCHEME_METASQ

constexpr LiteralId URLSCHEME_METASQ
constexpr

Scheme identifier for relative file links to the metadata of an asset in an SQL database.

See also
UrlScheme

◆ ID_MISSINGASSETS

constexpr LiteralId ID_MISSINGASSETS
staticconstexpr

Special asset id to declare missing assets in the dependency list. if this id appears in the dependencies, then the dependency asset was missing when creating the asset.

◆ PRESET_DEFAULT_CATEGORY

constexpr LiteralId PRESET_DEFAULT_CATEGORY
staticconstexpr

◆ NODE_PRESET_DEFAULT_CATEGORY

constexpr LiteralId NODE_PRESET_DEFAULT_CATEGORY
staticconstexpr

◆ ID_MISSINGNODESPACE

constexpr LiteralId ID_MISSINGNODESPACE
staticconstexpr

◆ ID_MISSINGPLUGIN

constexpr LiteralId ID_MISSINGPLUGIN
staticconstexpr

◆ TestForBeginFunction

decltype(begin(std::declval<T&>())) TestForBeginFunction(OverloadRank1) ( OverloadRank1  )

◆ TestForEndFunction

decltype(end(std::declval<T&>())) TestForEndFunction(OverloadRank1) ( OverloadRank1  )

◆ NO_MATCH

const NO_MATCH_TYPE NO_MATCH
static

◆ g_privateDays

const UInt32 g_privateDays[2][12]
static

◆ MAXON_ENUM_ORDERED_FLAGS

struct maxon::Wires MAXON_ENUM_ORDERED_FLAGS

◆ SYSTEM_BYTEORDER

const BYTEORDER SYSTEM_BYTEORDER

Indicates the active byte order on this system.

◆ g_hasSSE2

constexpr Bool g_hasSSE2
constexpr

◆ g_hasSSE3

constexpr Bool g_hasSSE3
constexpr

◆ g_hasSSSE3

constexpr Bool g_hasSSSE3
constexpr

◆ g_hasSSE4_1

constexpr Bool g_hasSSE4_1
constexpr

◆ g_hasSSE4_2

constexpr Bool g_hasSSE4_2
constexpr

◆ g_hasAVX

Bool g_hasAVX
extern

◆ g_hasFMA

Bool g_hasFMA
extern

◆ g_hasAES

Bool g_hasAES
extern

◆ g_hasPCLMULQDQ

Bool g_hasPCLMULQDQ
extern

◆ g_hasAVX2

Bool g_hasAVX2
extern

◆ g_CpuYieldDelegate

◆ g_trackCpuYield

Bool g_trackCpuYield
extern

◆ g_inCrashhandler

Bool g_inCrashhandler
extern

◆ DATADESCRIPTION_CATEGORY_DATA

constexpr LiteralId DATADESCRIPTION_CATEGORY_DATA
staticconstexpr

◆ DATADESCRIPTION_CATEGORY_UI

constexpr LiteralId DATADESCRIPTION_CATEGORY_UI
staticconstexpr

◆ DATADESCRIPTION_CATEGORY_STRING

constexpr LiteralId DATADESCRIPTION_CATEGORY_STRING
staticconstexpr

◆ EXTENSION_ID_SEPARATOR

constexpr Char EXTENSION_ID_SEPARATOR
staticconstexpr

Used as separator for extension points below and some special identifier tags.

◆ INITIALIZEHASH

const UInt INITIALIZEHASH
static

◆ FINALIZEHASH

const UInt FINALIZEHASH
static

◆ VALIDATEHASH

const UInt VALIDATEHASH
static

◆ g_writableMemory

Char g_writableMemory[1024]
extern

◆ Mantissa

const UInt32 Mantissa[2048]
extern

◆ Offset

const UInt16 Offset[64]
extern

◆ Exponent

const UInt32 Exponent[64]
extern

◆ Base

const UInt16 Base[512]
extern

◆ Shift

const UChar Shift[512]
extern

◆ ADDOBSERVER_DEFAULTPRIORITY

constexpr Int ADDOBSERVER_DEFAULTPRIORITY
staticconstexpr

◆ NO_VALUE

const NO_VALUE_TYPE NO_VALUE
static

◆ UNKNOWNPROGRESS

const Float UNKNOWNPROGRESS
static

predefined value if the progress has an unknown time (in that case the progress shows a spinning status).

◆ MAXTHREADS

const Int32 MAXTHREADS

◆ MaxDataSize

const Int32 MaxDataSize

◆ MaxDataNum

const Int32 MaxDataNum

◆ BYTEMAX

const Int32 BYTEMAX

◆ RADIXBITS

const Int32 RADIXBITS
static

◆ RADIXMASK

const Int32 RADIXMASK
static

◆ RADIXBIN

const Int32 RADIXBIN
static

◆ DEFAULT_APPENDSIZE

const Int DEFAULT_APPENDSIZE
static

◆ LANGUAGE_ENGLISH_ID

constexpr LiteralId LANGUAGE_ENGLISH_ID
staticconstexpr

◆ Ignore

const IgnoredPlaceholder Ignore
static

◆ g_javaHelper

JavaHelper g_javaHelper
extern

◆ FAILED

const ERROR_FAILED FAILED
static

FAILED can be used for comparison with a Result value. It indicates the failure of an operation:

Result<void> Func()
{
if (...)
return OutOfMemoryError(MAXON_SOURCE_LOCATION);
return OK;
}
if (Func() == FAILED)
{
...
}
static const ERROR_FAILED FAILED
Definition: resultbase.h:68

◆ returns_nonnull

const Error returns_nonnull

◆ g_freeThreadedStuff

HashSet<ThreadedUIUpdateBaseRef> g_freeThreadedStuff
static

◆ g_freeThreadedStuffLock

Spinlock g_freeThreadedStuffLock
static

◆ g_exitObservable

FunctionBaseRef g_exitObservable
static

◆ g_inShutDown

Bool g_inShutDown
static

◆ ConstantValue

const EffectivePortValue_PrivateHelper& ConstantValue
static

◆ DYNAMICDEGREE

constexpr Int DYNAMICDEGREE
staticconstexpr

◆ EPSS

const Float EPSS
static

◆ MR

const Int MR
static

◆ MT

const Int MT
static

◆ MAXIT

const Int MAXIT
static

◆ EPS

const Float EPS
static

◆ g_enableInCodeProfiler

Bool g_enableInCodeProfiler
extern

◆ g_enableProfilerDumpRegistry

Bool g_enableProfilerDumpRegistry
extern

◆ g_enableProfilerDumpRegistryErrors

Bool g_enableProfilerDumpRegistryErrors
extern

◆ g_enableProfilerGetMethodNameTrace

Bool g_enableProfilerGetMethodNameTrace
extern

◆ POINT_FUSE_EPS

const Float POINT_FUSE_EPS
static

◆ NETWORK_DEFAULT_CONNECT_TIMEOUT

const TimeValue NETWORK_DEFAULT_CONNECT_TIMEOUT
static

The default timeout for network connections. Is -1 for the internal default value.

◆ NETWORK_DEFAULT_SESSION_TIMEOUT

const TimeValue NETWORK_DEFAULT_SESSION_TIMEOUT
static

The default timeout for network sessions. Is -1 for the internal default value.

◆ SOCKETTIMEOUT_INDEFINITELY

◆ SOCKETTIMEOUT_NEVERBLOCK

◆ WILDCARD_IPV4_ADDRESS

const WILDCARD_IPV4_ADDRESS_TYPE WILDCARD_IPV4_ADDRESS
static

◆ WILDCARD_IPV6_ADDRESS

const WILDCARD_IPV6_ADDRESS_TYPE WILDCARD_IPV6_ADDRESS
static

◆ WILDCARD_IP_PORT

const Int WILDCARD_IP_PORT
static

Any IP port.

◆ ID_LOGGER_PYTHON

const Id ID_LOGGER_PYTHON
extern

◆ NATIVE_CO_MAXBLOCKS

const Int32 NATIVE_CO_MAXBLOCKS