Skip to content

Instantly share code, notes, and snippets.

@jmgomez

jmgomez/engine.nim

Created February 5, 2023 14:39
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save jmgomez/4bcd3984259d58bc4d7cfd8d3ba6b335 to your computer and use it in GitHub Desktop.
Save jmgomez/4bcd3984259d58bc4d7cfd8d3ba6b335 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
engine.nim
This file has been truncated, but you can view the full file.
include ../../prelude
import inputcore
import physicscore
import netcore
import clothingsystemruntimeinterface
import audioplatformconfiguration
import irisstub
import staticmeshdescription
import developersettings
import animationcore
import audioextensions
import typedelementframework
import typedelementruntime
import slatecore
import slate
import audiolinkcore
import megascansplugin
type
UBlueprintFunctionLibrary* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UBlueprintFunctionLibraryPtr* = ptr UBlueprintFunctionLibrary
UAssetExportTask* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UAssetExportTaskPtr* = ptr UAssetExportTask
UDataAsset* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UDataAssetPtr* = ptr UDataAsset
UMeshComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UPrimitiveComponent
UMeshComponentPtr* = ptr UMeshComponent
UBlueprintAsyncActionBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UBlueprintAsyncActionBasePtr* = ptr UBlueprintAsyncActionBase
AInfo* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AActor
AInfoPtr* = ptr AInfo
AGameStateBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AInfo
AGameStateBasePtr* = ptr AGameStateBase
ASkyLight* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AInfo
ASkyLightPtr* = ptr ASkyLight
UStreamableRenderAsset* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UStreamableRenderAssetPtr* = ptr UStreamableRenderAsset
UTexture* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UStreamableRenderAsset
UTexturePtr* = ptr UTexture
UTextureCube* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UTexture
UTextureCubePtr* = ptr UTextureCube
UStaticMeshComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMeshComponent
UStaticMeshComponentPtr* = ptr UStaticMeshComponent
UAssetImportData* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UAssetImportDataPtr* = ptr UAssetImportData
UDebugDrawComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UPrimitiveComponent
UDebugDrawComponentPtr* = ptr UDebugDrawComponent
UAISystemBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UAISystemBasePtr* = ptr UAISystemBase
ACharacter* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of APawn
ACharacterPtr* = ptr ACharacter
UNavLinkDefinition* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UNavLinkDefinitionPtr* = ptr UNavLinkDefinition
UNavAreaBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UNavAreaBasePtr* = ptr UNavAreaBase
UNavCollisionBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UNavCollisionBasePtr* = ptr UNavCollisionBase
UNavigationSystemBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UNavigationSystemBasePtr* = ptr UNavigationSystemBase
UNavigationDataChunk* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UNavigationDataChunkPtr* = ptr UNavigationDataChunk
ACameraActor* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AActor
ACameraActorPtr* = ptr ACameraActor
UCameraComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USceneComponent
UCameraComponentPtr* = ptr UCameraComponent
UDynamicBlueprintBinding* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UDynamicBlueprintBindingPtr* = ptr UDynamicBlueprintBinding
UGameInstance* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UGameInstancePtr* = ptr UGameInstance
UGameInstanceSubsystem* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USubsystem
UGameInstanceSubsystemPtr* = ptr UGameInstanceSubsystem
UEdGraphSchema* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UEdGraphSchemaPtr* = ptr UEdGraphSchema
USkinnedMeshComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMeshComponent
USkinnedMeshComponentPtr* = ptr USkinnedMeshComponent
USkeletalMeshComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USkinnedMeshComponent
USkeletalMeshComponentPtr* = ptr USkeletalMeshComponent
UAnimInstance* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UAnimInstancePtr* = ptr UAnimInstance
UAnimSingleNodeInstance* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UAnimInstance
UAnimSingleNodeInstancePtr* = ptr UAnimSingleNodeInstance
UAnimNotify* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UAnimNotifyPtr* = ptr UAnimNotify
UAnimNotifyState* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UAnimNotifyStatePtr* = ptr UAnimNotifyState
UEngineCustomTimeStep* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UEngineCustomTimeStepPtr* = ptr UEngineCustomTimeStep
UTimecodeProvider* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UTimecodeProviderPtr* = ptr UTimecodeProvider
USoundBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
USoundBasePtr* = ptr USoundBase
USoundWave* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundBase
USoundWavePtr* = ptr USoundWave
USoundEffectPreset* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
USoundEffectPresetPtr* = ptr USoundEffectPreset
USoundEffectSubmixPreset* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundEffectPreset
USoundEffectSubmixPresetPtr* = ptr USoundEffectSubmixPreset
UAssetUserData* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UAssetUserDataPtr* = ptr UAssetUserData
UExporter* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UExporterPtr* = ptr UExporter
UCommandlet* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UCommandletPtr* = ptr UCommandlet
UBrushBuilder* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UBrushBuilderPtr* = ptr UBrushBuilder
UEngine* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UEnginePtr* = ptr UEngine
UInstancedPlacemenClientSettings* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UObject
UInstancedPlacemenClientSettingsPtr* = ptr UInstancedPlacemenClientSettings
UMaterialInterface* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UMaterialInterfacePtr* = ptr UMaterialInterface
UMaterial* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialInterface
UMaterialPtr* = ptr UMaterial
UThumbnailInfo* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UThumbnailInfoPtr* = ptr UThumbnailInfo
ASkeletalMeshActor* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AActor
ASkeletalMeshActorPtr* = ptr ASkeletalMeshActor
UInstancedStaticMeshComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UStaticMeshComponent
UInstancedStaticMeshComponentPtr* = ptr UInstancedStaticMeshComponent
UHierarchicalInstancedStaticMeshComponent* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UInstancedStaticMeshComponent
UHierarchicalInstancedStaticMeshComponentPtr* = ptr UHierarchicalInstancedStaticMeshComponent
APartitionActor* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AActor
APartitionActorPtr* = ptr APartitionActor
AISMPartitionActor* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of APartitionActor
AISMPartitionActorPtr* = ptr AISMPartitionActor
AStaticMeshActor* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AActor
AStaticMeshActorPtr* = ptr AStaticMeshActor
UMaterialInstance* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialInterface
UMaterialInstancePtr* = ptr UMaterialInstance
UMaterialInstanceConstant* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialInstance
UMaterialInstanceConstantPtr* = ptr UMaterialInstanceConstant
UMaterialExpression* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UMaterialExpressionPtr* = ptr UMaterialExpression
UMaterialExpressionCustomOutput* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionCustomOutputPtr* = ptr UMaterialExpressionCustomOutput
UHLODBuilder* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UHLODBuilderPtr* = ptr UHLODBuilder
UActiveSoundUpdateInterface* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
UActiveSoundUpdateInterfacePtr* = ptr UActiveSoundUpdateInterface
UChannel* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UChannelPtr* = ptr UChannel
UActorReplicationBridge* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObjectReplicationBridge
UActorReplicationBridgePtr* = ptr UActorReplicationBridge
UAnimationAssetExtensions* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UAnimationAssetExtensionsPtr* = ptr UAnimationAssetExtensions
UAnimBlueprintClassSubsystem_PropertyAccess* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UObject
UAnimBlueprintClassSubsystem_PropertyAccessPtr* = ptr UAnimBlueprintClassSubsystem_PropertyAccess
UAnimationDataModelNotifiesExtensions* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UAnimationDataModelNotifiesExtensionsPtr* = ptr UAnimationDataModelNotifiesExtensions
UAnimLayerInterface* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
UAnimLayerInterfacePtr* = ptr UAnimLayerInterface
UAnimationAsset* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UAnimationAssetPtr* = ptr UAnimationAsset
UAnimSequenceBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UAnimationAsset
UAnimSequenceBasePtr* = ptr UAnimSequenceBase
URawAnimSequenceTrackExtensions* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
URawAnimSequenceTrackExtensionsPtr* = ptr URawAnimSequenceTrackExtensions
UAsyncPhysicsData* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UAsyncPhysicsDataPtr* = ptr UAsyncPhysicsData
UAudioPanelWidgetInterface* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
UAudioPanelWidgetInterfacePtr* = ptr UAudioPanelWidgetInterface
UBlendableInterface* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
UBlendableInterfacePtr* = ptr UBlendableInterface
UAnalysisProperties* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UAnalysisPropertiesPtr* = ptr UAnalysisProperties
UBlendSpace* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UAnimationAsset
UBlendSpacePtr* = ptr UBlendSpace
UBookmarkBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UBookmarkBasePtr* = ptr UBookmarkBase
AReflectionCapture* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AActor
AReflectionCapturePtr* = ptr AReflectionCapture
ABoxReflectionCapture* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AReflectionCapture
ABoxReflectionCapturePtr* = ptr ABoxReflectionCapture
UReflectionCaptureComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USceneComponent
UReflectionCaptureComponentPtr* = ptr UReflectionCaptureComponent
UBoxReflectionCaptureComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UReflectionCaptureComponent
UBoxReflectionCaptureComponentPtr* = ptr UBoxReflectionCaptureComponent
UBuiltInAttributesExtensions* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UBuiltInAttributesExtensionsPtr* = ptr UBuiltInAttributesExtensions
UPlayer* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UPlayerPtr* = ptr UPlayer
UNetConnection* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UPlayer
UNetConnectionPtr* = ptr UNetConnection
UChildConnection* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UNetConnection
UChildConnectionPtr* = ptr UChildConnection
UPlatformInterfaceBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UPlatformInterfaceBasePtr* = ptr UPlatformInterfaceBase
ALight* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AActor
ALightPtr* = ptr ALight
ADirectionalLight* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of ALight
ADirectionalLightPtr* = ptr ADirectionalLight
UDistribution* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UDistributionPtr* = ptr UDistribution
UDistributionFloat* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UDistribution
UDistributionFloatPtr* = ptr UDistributionFloat
UDistributionFloatParameterBase* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UDistributionFloat
UDistributionFloatParameterBasePtr* = ptr UDistributionFloatParameterBase
UDistributionVector* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UDistribution
UDistributionVectorPtr* = ptr UDistributionVector
UDistributionVectorParameterBase* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UDistributionVector
UDistributionVectorParameterBasePtr* = ptr UDistributionVectorParameterBase
UEdGraphPin_Deprecated* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UEdGraphPin_DeprecatedPtr* = ptr UEdGraphPin_Deprecated
AEmitter* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AActor
AEmitterPtr* = ptr AEmitter
AEmitterCameraLensEffectBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AEmitter
AEmitterCameraLensEffectBasePtr* = ptr AEmitterCameraLensEffectBase
UEngineBaseTypes* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UEngineBaseTypesPtr* = ptr UEngineBaseTypes
UEngineTypes* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UEngineTypesPtr* = ptr UEngineTypes
AExponentialHeightFog* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AInfo
AExponentialHeightFogPtr* = ptr AExponentialHeightFog
UExponentialHeightFogComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USceneComponent
UExponentialHeightFogComponentPtr* = ptr UExponentialHeightFogComponent
UFontImportOptions* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UFontImportOptionsPtr* = ptr UFontImportOptions
UForceFeedbackAttenuation* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UForceFeedbackAttenuationPtr* = ptr UForceFeedbackAttenuation
ASpotLight* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of ALight
ASpotLightPtr* = ptr ASpotLight
AGeneratedMeshAreaLight* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of ASpotLight
AGeneratedMeshAreaLightPtr* = ptr AGeneratedMeshAreaLight
UHapticFeedbackEffect_Base* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UHapticFeedbackEffect_BasePtr* = ptr UHapticFeedbackEffect_Base
UHapticFeedbackEffect_Buffer* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UHapticFeedbackEffect_Base
UHapticFeedbackEffect_BufferPtr* = ptr UHapticFeedbackEffect_Buffer
UHapticFeedbackEffect_Curve* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UHapticFeedbackEffect_Base
UHapticFeedbackEffect_CurvePtr* = ptr UHapticFeedbackEffect_Curve
UHapticFeedbackEffect_SoundWave* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UHapticFeedbackEffect_Base
UHapticFeedbackEffect_SoundWavePtr* = ptr UHapticFeedbackEffect_SoundWave
UAnimationDataController* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
UAnimationDataControllerPtr* = ptr UAnimationDataController
UInterface_ActorSubobject* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
UInterface_ActorSubobjectPtr* = ptr UInterface_ActorSubobject
UInterface_AssetUserData* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
UInterface_AssetUserDataPtr* = ptr UInterface_AssetUserData
UInterface_AsyncCompilation* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
UInterface_AsyncCompilationPtr* = ptr UInterface_AsyncCompilation
UBoneReferenceSkeletonProvider* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
UBoneReferenceSkeletonProviderPtr* = ptr UBoneReferenceSkeletonProvider
UInterface_CollisionDataProvider* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UInterface
UInterface_CollisionDataProviderPtr* = ptr UInterface_CollisionDataProvider
UInterface_PostProcessVolume* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
UInterface_PostProcessVolumePtr* = ptr UInterface_PostProcessVolume
UInterface_PreviewMeshProvider* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
UInterface_PreviewMeshProviderPtr* = ptr UInterface_PreviewMeshProvider
UISMPartitionInstanceManager* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
UISMPartitionInstanceManagerPtr* = ptr UISMPartitionInstanceManager
UISMPartitionInstanceManagerProvider* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UInterface
UISMPartitionInstanceManagerProviderPtr* = ptr UISMPartitionInstanceManagerProvider
UKismetTextLibrary* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UKismetTextLibraryPtr* = ptr UKismetTextLibrary
ULevelInstanceEditorPivotInterface* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UInterface
ULevelInstanceEditorPivotInterfacePtr* = ptr ULevelInstanceEditorPivotInterface
ULevelStreaming* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
ULevelStreamingPtr* = ptr ULevelStreaming
ULevelStreamingAlwaysLoaded* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of ULevelStreaming
ULevelStreamingAlwaysLoadedPtr* = ptr ULevelStreamingAlwaysLoaded
ULevelStreamingDynamic* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of ULevelStreaming
ULevelStreamingDynamicPtr* = ptr ULevelStreamingDynamic
ALevelStreamingVolume* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AVolume
ALevelStreamingVolumePtr* = ptr ALevelStreamingVolume
ULightComponentBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USceneComponent
ULightComponentBasePtr* = ptr ULightComponentBase
UTexture2D* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UTexture
UTexture2DPtr* = ptr UTexture2D
ULightMapTexture2D* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UTexture2D
ULightMapTexture2DPtr* = ptr ULightMapTexture2D
ALightmassPortal* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AActor
ALightmassPortalPtr* = ptr ALightmassPortal
ULightmassPortalComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USceneComponent
ULightmassPortalComponentPtr* = ptr ULightmassPortalComponent
UMapBuildDataRegistry* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UMapBuildDataRegistryPtr* = ptr UMapBuildDataRegistry
UMaterialEditorOnlyData* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UMaterialEditorOnlyDataPtr* = ptr UMaterialEditorOnlyData
UMaterialExpressionAbs* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionAbsPtr* = ptr UMaterialExpressionAbs
UMaterialExpressionAbsorptionMediumMaterialOutput* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionCustomOutput
UMaterialExpressionAbsorptionMediumMaterialOutputPtr* = ptr UMaterialExpressionAbsorptionMediumMaterialOutput
UMaterialExpressionAdd* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionAddPtr* = ptr UMaterialExpressionAdd
UMaterialExpressionTextureBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionTextureBasePtr* = ptr UMaterialExpressionTextureBase
UMaterialExpressionTextureSampleParameter* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionTextureBase
UMaterialExpressionTextureSampleParameterPtr* = ptr UMaterialExpressionTextureSampleParameter
UMaterialExpressionAntialiasedTextureMask* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionTextureSampleParameter
UMaterialExpressionAntialiasedTextureMaskPtr* = ptr UMaterialExpressionAntialiasedTextureMask
UMaterialExpressionAppendVector* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionAppendVectorPtr* = ptr UMaterialExpressionAppendVector
UMaterialExpressionArccosine* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionArccosinePtr* = ptr UMaterialExpressionArccosine
UMaterialExpressionArcsine* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionArcsinePtr* = ptr UMaterialExpressionArcsine
UMaterialExpressionArctangent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionArctangentPtr* = ptr UMaterialExpressionArctangent
UMaterialExpressionArctangent2* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionArctangent2Ptr* = ptr UMaterialExpressionArctangent2
UMaterialExpressionBinaryOp* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionBinaryOpPtr* = ptr UMaterialExpressionBinaryOp
UMaterialExpressionLess* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpressionBinaryOp
UMaterialExpressionLessPtr* = ptr UMaterialExpressionLess
UMaterialExpressionBlackBody* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionBlackBodyPtr* = ptr UMaterialExpressionBlackBody
UMaterialExpressionBlendMaterialAttributes* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionBlendMaterialAttributesPtr* = ptr UMaterialExpressionBlendMaterialAttributes
UMaterialExpressionBreakMaterialAttributes* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionBreakMaterialAttributesPtr* = ptr UMaterialExpressionBreakMaterialAttributes
UMaterialExpressionBumpOffset* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionBumpOffsetPtr* = ptr UMaterialExpressionBumpOffset
UMaterialExpressionCameraPositionWS* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionCameraPositionWSPtr* = ptr UMaterialExpressionCameraPositionWS
UMaterialExpressionCameraVectorWS* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionCameraVectorWSPtr* = ptr UMaterialExpressionCameraVectorWS
UMaterialExpressionCeil* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionCeilPtr* = ptr UMaterialExpressionCeil
UMaterialExpressionParameter* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionParameterPtr* = ptr UMaterialExpressionParameter
UMaterialExpressionVectorParameter* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionParameter
UMaterialExpressionVectorParameterPtr* = ptr UMaterialExpressionVectorParameter
UMaterialExpressionChannelMaskParameter* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionVectorParameter
UMaterialExpressionChannelMaskParameterPtr* = ptr UMaterialExpressionChannelMaskParameter
UMaterialExpressionClamp* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionClampPtr* = ptr UMaterialExpressionClamp
UMaterialExpressionClearCoatNormalCustomOutput* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionCustomOutput
UMaterialExpressionClearCoatNormalCustomOutputPtr* = ptr UMaterialExpressionClearCoatNormalCustomOutput
UMaterialExpressionCollectionParameter* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionCollectionParameterPtr* = ptr UMaterialExpressionCollectionParameter
UMaterialExpressionComment* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionCommentPtr* = ptr UMaterialExpressionComment
UMaterialExpressionComponentMask* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionComponentMaskPtr* = ptr UMaterialExpressionComponentMask
UMaterialExpressionComposite* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionCompositePtr* = ptr UMaterialExpressionComposite
UMaterialExpressionConstant* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionConstantPtr* = ptr UMaterialExpressionConstant
UMaterialExpressionConstant2Vector* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionConstant2VectorPtr* = ptr UMaterialExpressionConstant2Vector
UMaterialExpressionConstant3Vector* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionConstant3VectorPtr* = ptr UMaterialExpressionConstant3Vector
UMaterialExpressionConstant4Vector* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionConstant4VectorPtr* = ptr UMaterialExpressionConstant4Vector
UMaterialExpressionConstantBiasScale* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionConstantBiasScalePtr* = ptr UMaterialExpressionConstantBiasScale
UMaterialExpressionCosine* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionCosinePtr* = ptr UMaterialExpressionCosine
UMaterialExpressionCrossProduct* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionCrossProductPtr* = ptr UMaterialExpressionCrossProduct
UMaterialExpressionScalarParameter* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionParameter
UMaterialExpressionScalarParameterPtr* = ptr UMaterialExpressionScalarParameter
UMaterialExpressionCurveAtlasRowParameter* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionScalarParameter
UMaterialExpressionCurveAtlasRowParameterPtr* = ptr UMaterialExpressionCurveAtlasRowParameter
UMaterialExpressionCustom* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionCustomPtr* = ptr UMaterialExpressionCustom
UMaterialExpressionDDX* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionDDXPtr* = ptr UMaterialExpressionDDX
UMaterialExpressionDDY* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionDDYPtr* = ptr UMaterialExpressionDDY
UMaterialExpressionDesaturation* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionDesaturationPtr* = ptr UMaterialExpressionDesaturation
UMaterialExpressionDistance* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionDistancePtr* = ptr UMaterialExpressionDistance
UMaterialExpressionDivide* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionDividePtr* = ptr UMaterialExpressionDivide
UMaterialExpressionDotProduct* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionDotProductPtr* = ptr UMaterialExpressionDotProduct
UMaterialExpressionDoubleVectorParameter* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionParameter
UMaterialExpressionDoubleVectorParameterPtr* = ptr UMaterialExpressionDoubleVectorParameter
UMaterialExpressionDynamicParameter* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionDynamicParameterPtr* = ptr UMaterialExpressionDynamicParameter
UMaterialExpressionExecBegin* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionExecBeginPtr* = ptr UMaterialExpressionExecBegin
UMaterialExpressionExecEnd* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionExecEndPtr* = ptr UMaterialExpressionExecEnd
UMaterialExpressionFeatureLevelSwitch* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionFeatureLevelSwitchPtr* = ptr UMaterialExpressionFeatureLevelSwitch
UMaterialExpressionFloor* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionFloorPtr* = ptr UMaterialExpressionFloor
UMaterialExpressionFmod* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionFmodPtr* = ptr UMaterialExpressionFmod
UMaterialExpressionFontSample* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionFontSamplePtr* = ptr UMaterialExpressionFontSample
UMaterialExpressionFontSampleParameter* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionFontSample
UMaterialExpressionFontSampleParameterPtr* = ptr UMaterialExpressionFontSampleParameter
UMaterialExpressionForLoop* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionForLoopPtr* = ptr UMaterialExpressionForLoop
UMaterialExpressionFrac* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionFracPtr* = ptr UMaterialExpressionFrac
UMaterialExpressionFresnel* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionFresnelPtr* = ptr UMaterialExpressionFresnel
UMaterialExpressionFunctionInput* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionFunctionInputPtr* = ptr UMaterialExpressionFunctionInput
UMaterialExpressionFunctionOutput* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionFunctionOutputPtr* = ptr UMaterialExpressionFunctionOutput
UMaterialExpressionGenericConstant* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionGenericConstantPtr* = ptr UMaterialExpressionGenericConstant
UMaterialExpressionConstantDouble* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionGenericConstant
UMaterialExpressionConstantDoublePtr* = ptr UMaterialExpressionConstantDouble
UMaterialExpressionGetLocal* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionGetLocalPtr* = ptr UMaterialExpressionGetLocal
UMaterialExpressionGetMaterialAttributes* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionGetMaterialAttributesPtr* = ptr UMaterialExpressionGetMaterialAttributes
UMaterialExpressionHairAttributes* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionHairAttributesPtr* = ptr UMaterialExpressionHairAttributes
UMaterialExpressionHairColor* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionHairColorPtr* = ptr UMaterialExpressionHairColor
UMaterialExpressionIf* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionIfPtr* = ptr UMaterialExpressionIf
UMaterialExpressionIfThenElse* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionIfThenElsePtr* = ptr UMaterialExpressionIfThenElse
UMaterialExpressionInverseLinearInterpolate* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionInverseLinearInterpolatePtr* = ptr UMaterialExpressionInverseLinearInterpolate
UMaterialExpressionLinearInterpolate* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionLinearInterpolatePtr* = ptr UMaterialExpressionLinearInterpolate
UMaterialExpressionLogarithm10* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionLogarithm10Ptr* = ptr UMaterialExpressionLogarithm10
UMaterialExpressionLogarithm2* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionLogarithm2Ptr* = ptr UMaterialExpressionLogarithm2
UMaterialExpressionMakeMaterialAttributes* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionMakeMaterialAttributesPtr* = ptr UMaterialExpressionMakeMaterialAttributes
UMaterialExpressionMaterialAttributeLayers* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionMaterialAttributeLayersPtr* = ptr UMaterialExpressionMaterialAttributeLayers
UMaterialExpressionMaterialFunctionCall* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionMaterialFunctionCallPtr* = ptr UMaterialExpressionMaterialFunctionCall
UMaterialExpressionMaterialLayerOutput* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionFunctionOutput
UMaterialExpressionMaterialLayerOutputPtr* = ptr UMaterialExpressionMaterialLayerOutput
UMaterialExpressionMax* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionMaxPtr* = ptr UMaterialExpressionMax
UMaterialExpressionMin* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionMinPtr* = ptr UMaterialExpressionMin
UMaterialExpressionMultiply* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionMultiplyPtr* = ptr UMaterialExpressionMultiply
UMaterialExpressionRerouteBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionRerouteBasePtr* = ptr UMaterialExpressionRerouteBase
UMaterialExpressionNamedRerouteBase* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionRerouteBase
UMaterialExpressionNamedRerouteBasePtr* = ptr UMaterialExpressionNamedRerouteBase
UMaterialExpressionNoise* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionNoisePtr* = ptr UMaterialExpressionNoise
UMaterialExpressionNormalize* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionNormalizePtr* = ptr UMaterialExpressionNormalize
UMaterialExpressionOneMinus* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionOneMinusPtr* = ptr UMaterialExpressionOneMinus
UMaterialExpressionPanner* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionPannerPtr* = ptr UMaterialExpressionPanner
UMaterialExpressionParticleSubUV* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionTextureBase
UMaterialExpressionParticleSubUVPtr* = ptr UMaterialExpressionParticleSubUV
UMaterialExpressionParticleSubUVProperties* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionParticleSubUVPropertiesPtr* = ptr UMaterialExpressionParticleSubUVProperties
UMaterialExpressionPinBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionPinBasePtr* = ptr UMaterialExpressionPinBase
UMaterialExpressionPixelDepth* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionPixelDepthPtr* = ptr UMaterialExpressionPixelDepth
UMaterialExpressionPixelNormalWS* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionPixelNormalWSPtr* = ptr UMaterialExpressionPixelNormalWS
UMaterialExpressionPower* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionPowerPtr* = ptr UMaterialExpressionPower
UMaterialExpressionPreSkinnedNormal* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionPreSkinnedNormalPtr* = ptr UMaterialExpressionPreSkinnedNormal
UMaterialExpressionPreSkinnedPosition* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionPreSkinnedPositionPtr* = ptr UMaterialExpressionPreSkinnedPosition
UMaterialExpressionPreviousFrameSwitch* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionPreviousFrameSwitchPtr* = ptr UMaterialExpressionPreviousFrameSwitch
UMaterialExpressionQualitySwitch* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionQualitySwitchPtr* = ptr UMaterialExpressionQualitySwitch
UMaterialExpressionReflectionVectorWS* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionReflectionVectorWSPtr* = ptr UMaterialExpressionReflectionVectorWS
UMaterialExpressionRotateAboutAxis* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionRotateAboutAxisPtr* = ptr UMaterialExpressionRotateAboutAxis
UMaterialExpressionRuntimeVirtualTextureSampleParameter* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionRuntimeVirtualTextureSampleParameterPtr* = ptr UMaterialExpressionRuntimeVirtualTextureSampleParameter
UMaterialExpressionSaturate* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionSaturatePtr* = ptr UMaterialExpressionSaturate
UMaterialExpressionSetLocal* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionSetLocalPtr* = ptr UMaterialExpressionSetLocal
UMaterialExpressionSetMaterialAttributes* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionSetMaterialAttributesPtr* = ptr UMaterialExpressionSetMaterialAttributes
UMaterialExpressionShaderStageSwitch* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionShaderStageSwitchPtr* = ptr UMaterialExpressionShaderStageSwitch
UMaterialExpressionShadingModel* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionShadingModelPtr* = ptr UMaterialExpressionShadingModel
UMaterialExpressionShadingPathSwitch* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionShadingPathSwitchPtr* = ptr UMaterialExpressionShadingPathSwitch
UMaterialExpressionSine* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionSinePtr* = ptr UMaterialExpressionSine
UMaterialExpressionSingleLayerWaterMaterialOutput* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionCustomOutput
UMaterialExpressionSingleLayerWaterMaterialOutputPtr* = ptr UMaterialExpressionSingleLayerWaterMaterialOutput
UMaterialExpressionSmoothStep* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionSmoothStepPtr* = ptr UMaterialExpressionSmoothStep
UMaterialExpressionSobol* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionSobolPtr* = ptr UMaterialExpressionSobol
UMaterialExpressionSpeedTree* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionSpeedTreePtr* = ptr UMaterialExpressionSpeedTree
UMaterialExpressionSphereMask* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionSphereMaskPtr* = ptr UMaterialExpressionSphereMask
UMaterialExpressionSquareRoot* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionSquareRootPtr* = ptr UMaterialExpressionSquareRoot
UMaterialExpressionStaticBool* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionStaticBoolPtr* = ptr UMaterialExpressionStaticBool
UMaterialExpressionStaticBoolParameter* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionParameter
UMaterialExpressionStaticBoolParameterPtr* = ptr UMaterialExpressionStaticBoolParameter
UMaterialExpressionStaticComponentMaskParameter* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionParameter
UMaterialExpressionStaticComponentMaskParameterPtr* = ptr UMaterialExpressionStaticComponentMaskParameter
UMaterialExpressionStaticSwitch* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionStaticSwitchPtr* = ptr UMaterialExpressionStaticSwitch
UMaterialExpressionStaticSwitchParameter* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionStaticBoolParameter
UMaterialExpressionStaticSwitchParameterPtr* = ptr UMaterialExpressionStaticSwitchParameter
UMaterialExpressionStep* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionStepPtr* = ptr UMaterialExpressionStep
UMaterialExpressionStrataBSDF* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionStrataBSDFPtr* = ptr UMaterialExpressionStrataBSDF
UMaterialExpressionStrataLegacyConversion* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionStrataBSDF
UMaterialExpressionStrataLegacyConversionPtr* = ptr UMaterialExpressionStrataLegacyConversion
UMaterialExpressionStrataSlabBSDF* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionStrataBSDF
UMaterialExpressionStrataSlabBSDFPtr* = ptr UMaterialExpressionStrataSlabBSDF
UMaterialExpressionStrataSimpleClearCoatBSDF* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionStrataBSDF
UMaterialExpressionStrataSimpleClearCoatBSDFPtr* = ptr UMaterialExpressionStrataSimpleClearCoatBSDF
UMaterialExpressionStrataVolumetricFogCloudBSDF* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionStrataBSDF
UMaterialExpressionStrataVolumetricFogCloudBSDFPtr* = ptr UMaterialExpressionStrataVolumetricFogCloudBSDF
UMaterialExpressionStrataUnlitBSDF* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionStrataBSDF
UMaterialExpressionStrataUnlitBSDFPtr* = ptr UMaterialExpressionStrataUnlitBSDF
UMaterialExpressionStrataHairBSDF* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionStrataBSDF
UMaterialExpressionStrataHairBSDFPtr* = ptr UMaterialExpressionStrataHairBSDF
UMaterialExpressionStrataEyeBSDF* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionStrataBSDF
UMaterialExpressionStrataEyeBSDFPtr* = ptr UMaterialExpressionStrataEyeBSDF
UMaterialExpressionStrataSingleLayerWaterBSDF* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionStrataBSDF
UMaterialExpressionStrataSingleLayerWaterBSDFPtr* = ptr UMaterialExpressionStrataSingleLayerWaterBSDF
UMaterialExpressionStrataLightFunction* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionStrataBSDF
UMaterialExpressionStrataLightFunctionPtr* = ptr UMaterialExpressionStrataLightFunction
UMaterialExpressionStrataPostProcess* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionStrataBSDF
UMaterialExpressionStrataPostProcessPtr* = ptr UMaterialExpressionStrataPostProcess
UMaterialExpressionStrataConvertToDecal* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionStrataBSDF
UMaterialExpressionStrataConvertToDecalPtr* = ptr UMaterialExpressionStrataConvertToDecal
UMaterialExpressionStrataHorizontalMixing* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionStrataBSDF
UMaterialExpressionStrataHorizontalMixingPtr* = ptr UMaterialExpressionStrataHorizontalMixing
UMaterialExpressionStrataVerticalLayering* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionStrataBSDF
UMaterialExpressionStrataVerticalLayeringPtr* = ptr UMaterialExpressionStrataVerticalLayering
UMaterialExpressionStrataAdd* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpressionStrataBSDF
UMaterialExpressionStrataAddPtr* = ptr UMaterialExpressionStrataAdd
UMaterialExpressionStrataWeight* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionStrataBSDF
UMaterialExpressionStrataWeightPtr* = ptr UMaterialExpressionStrataWeight
UMaterialExpressionStrataThinFilm* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionStrataBSDF
UMaterialExpressionStrataThinFilmPtr* = ptr UMaterialExpressionStrataThinFilm
UMaterialExpressionStrataUtilityBase* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionStrataUtilityBasePtr* = ptr UMaterialExpressionStrataUtilityBase
UMaterialExpressionStrataTransmittanceToMFP* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionStrataUtilityBase
UMaterialExpressionStrataTransmittanceToMFPPtr* = ptr UMaterialExpressionStrataTransmittanceToMFP
UMaterialExpressionStrataMetalnessToDiffuseAlbedoF0* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionStrataUtilityBase
UMaterialExpressionStrataMetalnessToDiffuseAlbedoF0Ptr* = ptr UMaterialExpressionStrataMetalnessToDiffuseAlbedoF0
UMaterialExpressionStrataHazinessToSecondaryRoughness* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionStrataUtilityBase
UMaterialExpressionStrataHazinessToSecondaryRoughnessPtr* = ptr UMaterialExpressionStrataHazinessToSecondaryRoughness
UMaterialExpressionSubtract* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionSubtractPtr* = ptr UMaterialExpressionSubtract
UMaterialExpressionTangent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionTangentPtr* = ptr UMaterialExpressionTangent
UMaterialExpressionTangentOutput* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionCustomOutput
UMaterialExpressionTangentOutputPtr* = ptr UMaterialExpressionTangentOutput
UMaterialExpressionTemporalSobol* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionTemporalSobolPtr* = ptr UMaterialExpressionTemporalSobol
UMaterialExpressionTextureCoordinate* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionTextureCoordinatePtr* = ptr UMaterialExpressionTextureCoordinate
UMaterialExpressionTextureObject* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionTextureBase
UMaterialExpressionTextureObjectPtr* = ptr UMaterialExpressionTextureObject
UMaterialExpressionTextureObjectParameter* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionTextureSampleParameter
UMaterialExpressionTextureObjectParameterPtr* = ptr UMaterialExpressionTextureObjectParameter
UMaterialExpressionTextureSampleParameter2DArray* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionTextureSampleParameter
UMaterialExpressionTextureSampleParameter2DArrayPtr* = ptr UMaterialExpressionTextureSampleParameter2DArray
UMaterialExpressionTextureSampleParameterCube* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionTextureSampleParameter
UMaterialExpressionTextureSampleParameterCubePtr* = ptr UMaterialExpressionTextureSampleParameterCube
UMaterialExpressionTextureSampleParameterCubeArray* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionTextureSampleParameter
UMaterialExpressionTextureSampleParameterCubeArrayPtr* = ptr UMaterialExpressionTextureSampleParameterCubeArray
UMaterialExpressionTextureSampleParameterSubUV* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionTextureSampleParameter
UMaterialExpressionTextureSampleParameterSubUVPtr* = ptr UMaterialExpressionTextureSampleParameterSubUV
UMaterialExpressionTextureSampleParameterVolume* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionTextureSampleParameter
UMaterialExpressionTextureSampleParameterVolumePtr* = ptr UMaterialExpressionTextureSampleParameterVolume
UMaterialExpressionThinTranslucentMaterialOutput* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionCustomOutput
UMaterialExpressionThinTranslucentMaterialOutputPtr* = ptr UMaterialExpressionThinTranslucentMaterialOutput
UMaterialExpressionTime* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionTimePtr* = ptr UMaterialExpressionTime
UMaterialExpressionTransform* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionTransformPtr* = ptr UMaterialExpressionTransform
UMaterialExpressionTransformPosition* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionTransformPositionPtr* = ptr UMaterialExpressionTransformPosition
UMaterialExpressionTwoSidedSign* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionTwoSidedSignPtr* = ptr UMaterialExpressionTwoSidedSign
UMaterialExpressionVectorNoise* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionVectorNoisePtr* = ptr UMaterialExpressionVectorNoise
UMaterialExpressionVertexColor* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionVertexColorPtr* = ptr UMaterialExpressionVertexColor
UMaterialExpressionVertexInterpolator* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionCustomOutput
UMaterialExpressionVertexInterpolatorPtr* = ptr UMaterialExpressionVertexInterpolator
UMaterialExpressionVertexNormalWS* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionVertexNormalWSPtr* = ptr UMaterialExpressionVertexNormalWS
UMaterialExpressionVertexTangentWS* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionVertexTangentWSPtr* = ptr UMaterialExpressionVertexTangentWS
UMaterialExpressionViewProperty* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionViewPropertyPtr* = ptr UMaterialExpressionViewProperty
UMaterialExpressionVolumetricAdvancedMaterialOutput* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpressionCustomOutput
UMaterialExpressionVolumetricAdvancedMaterialOutputPtr* = ptr UMaterialExpressionVolumetricAdvancedMaterialOutput
UMaterialExpressionVolumetricCloudEmptySpaceSkippingOutput* {.
importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpressionCustomOutput
UMaterialExpressionVolumetricCloudEmptySpaceSkippingOutputPtr* = ptr UMaterialExpressionVolumetricCloudEmptySpaceSkippingOutput
UMaterialExpressionWhileLoop* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionWhileLoopPtr* = ptr UMaterialExpressionWhileLoop
UMaterialExpressionWorldPosition* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialExpression
UMaterialExpressionWorldPositionPtr* = ptr UMaterialExpressionWorldPosition
UMaterialFunctionEditorOnlyData* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UObject
UMaterialFunctionEditorOnlyDataPtr* = ptr UMaterialFunctionEditorOnlyData
UMaterialFunctionInterface* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UMaterialFunctionInterfacePtr* = ptr UMaterialFunctionInterface
UMaterialFunction* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialFunctionInterface
UMaterialFunctionPtr* = ptr UMaterialFunction
UMaterialFunctionInstance* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialFunctionInterface
UMaterialFunctionInstancePtr* = ptr UMaterialFunctionInstance
UMaterialFunctionMaterialLayer* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialFunction
UMaterialFunctionMaterialLayerPtr* = ptr UMaterialFunctionMaterialLayer
UMaterialFunctionMaterialLayerInstance* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialFunctionInstance
UMaterialFunctionMaterialLayerInstancePtr* = ptr UMaterialFunctionMaterialLayerInstance
UMaterialFunctionMaterialLayerBlend* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialFunction
UMaterialFunctionMaterialLayerBlendPtr* = ptr UMaterialFunctionMaterialLayerBlend
UMaterialFunctionMaterialLayerBlendInstance* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UMaterialFunctionInstance
UMaterialFunctionMaterialLayerBlendInstancePtr* = ptr UMaterialFunctionMaterialLayerBlendInstance
UMaterialParameterCollection* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UMaterialParameterCollectionPtr* = ptr UMaterialParameterCollection
UMeshDeformer* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UMeshDeformerPtr* = ptr UMeshDeformer
UMeshDeformerInstanceSettings* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UMeshDeformerInstanceSettingsPtr* = ptr UMeshDeformerInstanceSettings
UMeshDeformerInstance* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UMeshDeformerInstancePtr* = ptr UMeshDeformerInstance
UMorphTarget* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UMorphTargetPtr* = ptr UMorphTarget
UNavAgentInterface* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
UNavAgentInterfacePtr* = ptr UNavAgentInterface
UNavEdgeProviderInterface* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
UNavEdgeProviderInterfacePtr* = ptr UNavEdgeProviderInterface
UNavigationDataInterface* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
UNavigationDataInterfacePtr* = ptr UNavigationDataInterface
UNavPathObserverInterface* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
UNavPathObserverInterfacePtr* = ptr UNavPathObserverInterface
UNavRelevantInterface* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
UNavRelevantInterfacePtr* = ptr UNavRelevantInterface
UNetworkPredictionInterface* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
UNetworkPredictionInterfacePtr* = ptr UNetworkPredictionInterface
UParticleEmitter* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UParticleEmitterPtr* = ptr UParticleEmitter
UParticleLODLevel* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UParticleLODLevelPtr* = ptr UParticleLODLevel
UFXSystemAsset* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UFXSystemAssetPtr* = ptr UFXSystemAsset
UParticleSystem* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UFXSystemAsset
UParticleSystemPtr* = ptr UParticleSystem
UParticleModule* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UParticleModulePtr* = ptr UParticleModule
UParticleModuleAccelerationBase* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UParticleModule
UParticleModuleAccelerationBasePtr* = ptr UParticleModuleAccelerationBase
UParticleModuleAcceleration* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleAccelerationBase
UParticleModuleAccelerationPtr* = ptr UParticleModuleAcceleration
UParticleModuleAccelerationConstant* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UParticleModuleAccelerationBase
UParticleModuleAccelerationConstantPtr* = ptr UParticleModuleAccelerationConstant
UParticleModuleAccelerationDrag* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UParticleModuleAccelerationBase
UParticleModuleAccelerationDragPtr* = ptr UParticleModuleAccelerationDrag
UParticleModuleAccelerationDragScaleOverLife* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UParticleModuleAccelerationBase
UParticleModuleAccelerationDragScaleOverLifePtr* = ptr UParticleModuleAccelerationDragScaleOverLife
UParticleModuleAccelerationOverLifetime* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UParticleModuleAccelerationBase
UParticleModuleAccelerationOverLifetimePtr* = ptr UParticleModuleAccelerationOverLifetime
UParticleModuleAttractorBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModule
UParticleModuleAttractorBasePtr* = ptr UParticleModuleAttractorBase
UParticleModuleAttractorLine* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleAttractorBase
UParticleModuleAttractorLinePtr* = ptr UParticleModuleAttractorLine
UParticleModuleAttractorParticle* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UParticleModuleAttractorBase
UParticleModuleAttractorParticlePtr* = ptr UParticleModuleAttractorParticle
UParticleModuleAttractorPoint* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleAttractorBase
UParticleModuleAttractorPointPtr* = ptr UParticleModuleAttractorPoint
UParticleModuleBeamBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModule
UParticleModuleBeamBasePtr* = ptr UParticleModuleBeamBase
UParticleModuleBeamNoise* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleBeamBase
UParticleModuleBeamNoisePtr* = ptr UParticleModuleBeamNoise
UParticleModuleBeamSource* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleBeamBase
UParticleModuleBeamSourcePtr* = ptr UParticleModuleBeamSource
UParticleModuleBeamTarget* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleBeamBase
UParticleModuleBeamTargetPtr* = ptr UParticleModuleBeamTarget
UParticleModuleCameraBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModule
UParticleModuleCameraBasePtr* = ptr UParticleModuleCameraBase
UParticleModuleCameraOffset* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleCameraBase
UParticleModuleCameraOffsetPtr* = ptr UParticleModuleCameraOffset
UParticleModuleCollisionBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModule
UParticleModuleCollisionBasePtr* = ptr UParticleModuleCollisionBase
UParticleModuleCollision* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleCollisionBase
UParticleModuleCollisionPtr* = ptr UParticleModuleCollision
UParticleModuleCollisionGPU* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleCollisionBase
UParticleModuleCollisionGPUPtr* = ptr UParticleModuleCollisionGPU
UParticleModuleColorBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModule
UParticleModuleColorBasePtr* = ptr UParticleModuleColorBase
UParticleModuleColorOverLife* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleColorBase
UParticleModuleColorOverLifePtr* = ptr UParticleModuleColorOverLife
UParticleModuleColorScaleOverLife* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UParticleModuleColorBase
UParticleModuleColorScaleOverLifePtr* = ptr UParticleModuleColorScaleOverLife
UParticleModuleEventBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModule
UParticleModuleEventBasePtr* = ptr UParticleModuleEventBase
UParticleModuleEventGenerator* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleEventBase
UParticleModuleEventGeneratorPtr* = ptr UParticleModuleEventGenerator
UParticleModuleEventReceiverBase* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UParticleModuleEventBase
UParticleModuleEventReceiverBasePtr* = ptr UParticleModuleEventReceiverBase
UParticleModuleEventSendToGame* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UParticleModuleEventSendToGamePtr* = ptr UParticleModuleEventSendToGame
UParticleModuleKillBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModule
UParticleModuleKillBasePtr* = ptr UParticleModuleKillBase
UParticleModuleLifetimeBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModule
UParticleModuleLifetimeBasePtr* = ptr UParticleModuleLifetimeBase
UParticleModuleLifetime* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleLifetimeBase
UParticleModuleLifetimePtr* = ptr UParticleModuleLifetime
UParticleModuleLightBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModule
UParticleModuleLightBasePtr* = ptr UParticleModuleLightBase
UParticleModuleLight* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleLightBase
UParticleModuleLightPtr* = ptr UParticleModuleLight
UParticleModuleLight_Seeded* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleLight
UParticleModuleLight_SeededPtr* = ptr UParticleModuleLight_Seeded
UParticleModuleLocationBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModule
UParticleModuleLocationBasePtr* = ptr UParticleModuleLocationBase
UParticleModuleMaterialBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModule
UParticleModuleMaterialBasePtr* = ptr UParticleModuleMaterialBase
UParticleModuleMeshMaterial* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleMaterialBase
UParticleModuleMeshMaterialPtr* = ptr UParticleModuleMeshMaterial
UParticleModuleRotationBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModule
UParticleModuleRotationBasePtr* = ptr UParticleModuleRotationBase
UParticleModuleMeshRotation* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleRotationBase
UParticleModuleMeshRotationPtr* = ptr UParticleModuleMeshRotation
UParticleModuleRotationRateBase* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UParticleModule
UParticleModuleRotationRateBasePtr* = ptr UParticleModuleRotationRateBase
UParticleModuleMeshRotationRate* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UParticleModuleRotationRateBase
UParticleModuleMeshRotationRatePtr* = ptr UParticleModuleMeshRotationRate
UParticleModuleOrbitBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModule
UParticleModuleOrbitBasePtr* = ptr UParticleModuleOrbitBase
UParticleModuleOrbit* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleOrbitBase
UParticleModuleOrbitPtr* = ptr UParticleModuleOrbit
UParticleModuleOrientationBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModule
UParticleModuleOrientationBasePtr* = ptr UParticleModuleOrientationBase
UParticleModuleOrientationAxisLock* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UParticleModuleOrientationBase
UParticleModuleOrientationAxisLockPtr* = ptr UParticleModuleOrientationAxisLock
UParticleModuleParameterBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModule
UParticleModuleParameterBasePtr* = ptr UParticleModuleParameterBase
UParticleModuleParameterDynamic* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UParticleModuleParameterBase
UParticleModuleParameterDynamicPtr* = ptr UParticleModuleParameterDynamic
UParticleModuleRequired* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModule
UParticleModuleRequiredPtr* = ptr UParticleModuleRequired
UParticleModuleRotation* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleRotationBase
UParticleModuleRotationPtr* = ptr UParticleModuleRotation
UParticleModuleRotationOverLifetime* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UParticleModuleRotationBase
UParticleModuleRotationOverLifetimePtr* = ptr UParticleModuleRotationOverLifetime
UParticleModuleRotationRate* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleRotationRateBase
UParticleModuleRotationRatePtr* = ptr UParticleModuleRotationRate
UParticleModuleRotationRateMultiplyLife* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UParticleModuleRotationRateBase
UParticleModuleRotationRateMultiplyLifePtr* = ptr UParticleModuleRotationRateMultiplyLife
UParticleModuleSizeBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModule
UParticleModuleSizeBasePtr* = ptr UParticleModuleSizeBase
UParticleModuleSize* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleSizeBase
UParticleModuleSizePtr* = ptr UParticleModuleSize
UParticleModuleSizeMultiplyLife* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UParticleModuleSizeBase
UParticleModuleSizeMultiplyLifePtr* = ptr UParticleModuleSizeMultiplyLife
UParticleModuleSizeScale* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleSizeBase
UParticleModuleSizeScalePtr* = ptr UParticleModuleSizeScale
UParticleModuleSizeScaleBySpeed* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UParticleModuleSizeBase
UParticleModuleSizeScaleBySpeedPtr* = ptr UParticleModuleSizeScaleBySpeed
UParticleModuleSpawnBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModule
UParticleModuleSpawnBasePtr* = ptr UParticleModuleSpawnBase
UParticleModuleSpawn* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleSpawnBase
UParticleModuleSpawnPtr* = ptr UParticleModuleSpawn
UParticleModuleSpawnPerUnit* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleSpawnBase
UParticleModuleSpawnPerUnitPtr* = ptr UParticleModuleSpawnPerUnit
UParticleModuleSubUVBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModule
UParticleModuleSubUVBasePtr* = ptr UParticleModuleSubUVBase
UParticleModuleSubUV* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleSubUVBase
UParticleModuleSubUVPtr* = ptr UParticleModuleSubUV
UParticleModuleSubUVMovie* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleSubUV
UParticleModuleSubUVMoviePtr* = ptr UParticleModuleSubUVMovie
UParticleModuleTrailBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModule
UParticleModuleTrailBasePtr* = ptr UParticleModuleTrailBase
UParticleModuleTrailSource* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleTrailBase
UParticleModuleTrailSourcePtr* = ptr UParticleModuleTrailSource
UParticleModuleTypeDataBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModule
UParticleModuleTypeDataBasePtr* = ptr UParticleModuleTypeDataBase
UParticleModuleTypeDataAnimTrail* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UParticleModuleTypeDataBase
UParticleModuleTypeDataAnimTrailPtr* = ptr UParticleModuleTypeDataAnimTrail
UParticleModuleTypeDataBeam2* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleTypeDataBase
UParticleModuleTypeDataBeam2Ptr* = ptr UParticleModuleTypeDataBeam2
UParticleModuleTypeDataGpu* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleTypeDataBase
UParticleModuleTypeDataGpuPtr* = ptr UParticleModuleTypeDataGpu
UParticleModuleTypeDataMesh* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleTypeDataBase
UParticleModuleTypeDataMeshPtr* = ptr UParticleModuleTypeDataMesh
UParticleModuleTypeDataRibbon* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleTypeDataBase
UParticleModuleTypeDataRibbonPtr* = ptr UParticleModuleTypeDataRibbon
UParticleModuleVectorFieldBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModule
UParticleModuleVectorFieldBasePtr* = ptr UParticleModuleVectorFieldBase
UParticleModuleVectorFieldLocal* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UParticleModuleVectorFieldBase
UParticleModuleVectorFieldLocalPtr* = ptr UParticleModuleVectorFieldLocal
UParticleModuleVectorFieldRotationRate* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UParticleModuleVectorFieldBase
UParticleModuleVectorFieldRotationRatePtr* = ptr UParticleModuleVectorFieldRotationRate
UParticleModuleVectorFieldScale* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UParticleModuleVectorFieldBase
UParticleModuleVectorFieldScalePtr* = ptr UParticleModuleVectorFieldScale
UParticleModuleVectorFieldScaleOverLife* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UParticleModuleVectorFieldBase
UParticleModuleVectorFieldScaleOverLifePtr* = ptr UParticleModuleVectorFieldScaleOverLife
UParticleModuleVelocityBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModule
UParticleModuleVelocityBasePtr* = ptr UParticleModuleVelocityBase
UParticleModuleVelocity* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleVelocityBase
UParticleModuleVelocityPtr* = ptr UParticleModuleVelocity
UParticleModuleVelocityCone* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleModuleVelocityBase
UParticleModuleVelocityConePtr* = ptr UParticleModuleVelocityCone
UParticleModuleVelocityInheritParent* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UParticleModuleVelocityBase
UParticleModuleVelocityInheritParentPtr* = ptr UParticleModuleVelocityInheritParent
UParticleModuleVelocityOverLifetime* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UParticleModuleVelocityBase
UParticleModuleVelocityOverLifetimePtr* = ptr UParticleModuleVelocityOverLifetime
UParticleSpriteEmitter* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UParticleEmitter
UParticleSpriteEmitterPtr* = ptr UParticleSpriteEmitter
UFXSystemComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UPrimitiveComponent
UFXSystemComponentPtr* = ptr UFXSystemComponent
UParticleSystemComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UFXSystemComponent
UParticleSystemComponentPtr* = ptr UParticleSystemComponent
UPathFollowingAgentInterface* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
UPathFollowingAgentInterfacePtr* = ptr UPathFollowingAgentInterface
UPhysicsSpringComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USceneComponent
UPhysicsSpringComponentPtr* = ptr UPhysicsSpringComponent
UPhysicsThreadLibrary* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UPhysicsThreadLibraryPtr* = ptr UPhysicsThreadLibrary
UPhysicsThrusterComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USceneComponent
UPhysicsThrusterComponentPtr* = ptr UPhysicsThrusterComponent
ASceneCapture* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AActor
ASceneCapturePtr* = ptr ASceneCapture
APlanarReflection* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of ASceneCapture
APlanarReflectionPtr* = ptr APlanarReflection
USceneCaptureComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USceneComponent
USceneCaptureComponentPtr* = ptr USceneCaptureComponent
UPlanarReflectionComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USceneCaptureComponent
UPlanarReflectionComponentPtr* = ptr UPlanarReflectionComponent
APlaneReflectionCapture* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AReflectionCapture
APlaneReflectionCapturePtr* = ptr APlaneReflectionCapture
UPlaneReflectionCaptureComponent* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UReflectionCaptureComponent
UPlaneReflectionCaptureComponentPtr* = ptr UPlaneReflectionCaptureComponent
UPlatformInterfaceWebResponse* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UPlatformInterfaceWebResponsePtr* = ptr UPlatformInterfaceWebResponse
APlayerCameraManager* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AActor
APlayerCameraManagerPtr* = ptr APlayerCameraManager
UPlayerStateCountLimiterConfig* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UNetObjectCountLimiterConfig
UPlayerStateCountLimiterConfigPtr* = ptr UPlayerStateCountLimiterConfig
APointLight* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of ALight
APointLightPtr* = ptr APointLight
UPolys* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UPolysPtr* = ptr UPolys
APrecomputedVisibilityOverrideVolume* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of AVolume
APrecomputedVisibilityOverrideVolumePtr* = ptr APrecomputedVisibilityOverrideVolume
ARigidBodyBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AActor
ARigidBodyBasePtr* = ptr ARigidBodyBase
ARadialForceActor* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of ARigidBodyBase
ARadialForceActorPtr* = ptr ARadialForceActor
UReplicationDriver* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UReplicationDriverPtr* = ptr UReplicationDriver
UReplicationConnectionDriver* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UReplicationConnectionDriverPtr* = ptr UReplicationConnectionDriver
URVOAvoidanceInterface* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
URVOAvoidanceInterfacePtr* = ptr URVOAvoidanceInterface
ASceneCapture2D* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of ASceneCapture
ASceneCapture2DPtr* = ptr ASceneCapture2D
USceneCaptureComponent2D* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USceneCaptureComponent
USceneCaptureComponent2DPtr* = ptr USceneCaptureComponent2D
USceneCaptureComponentCube* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USceneCaptureComponent
USceneCaptureComponentCubePtr* = ptr USceneCaptureComponentCube
ASceneCaptureCube* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of ASceneCapture
ASceneCaptureCubePtr* = ptr ASceneCaptureCube
UShadowMapTexture2D* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UTexture2D
UShadowMapTexture2DPtr* = ptr UShadowMapTexture2D
USkeletalMeshSocket* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
USkeletalMeshSocketPtr* = ptr USkeletalMeshSocket
USkinnedAsset* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UStreamableRenderAsset
USkinnedAssetPtr* = ptr USkinnedAsset
USkyLightComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of ULightComponentBase
USkyLightComponentPtr* = ptr USkyLightComponent
USMInstanceManager* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
USMInstanceManagerPtr* = ptr USMInstanceManager
USMInstanceManagerProvider* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
USMInstanceManagerProviderPtr* = ptr USMInstanceManagerProvider
USoundAttenuation* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
USoundAttenuationPtr* = ptr USoundAttenuation
USoundEffectPresetWidgetInterface* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UAudioPanelWidgetInterface
USoundEffectPresetWidgetInterfacePtr* = ptr USoundEffectPresetWidgetInterface
USoundEffectSourcePreset* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundEffectPreset
USoundEffectSourcePresetPtr* = ptr USoundEffectSourcePreset
USoundEffectSourcePresetChain* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
USoundEffectSourcePresetChainPtr* = ptr USoundEffectSourcePresetChain
USoundGroups* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
USoundGroupsPtr* = ptr USoundGroups
USoundNode* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
USoundNodePtr* = ptr USoundNode
USoundNodeModulatorContinuous* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundNode
USoundNodeModulatorContinuousPtr* = ptr USoundNodeModulatorContinuous
USoundSubmixWidgetInterface* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
USoundSubmixWidgetInterfacePtr* = ptr USoundSubmixWidgetInterface
ASphereReflectionCapture* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AReflectionCapture
ASphereReflectionCapturePtr* = ptr ASphereReflectionCapture
USphereReflectionCaptureComponent* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UReflectionCaptureComponent
USphereReflectionCaptureComponentPtr* = ptr USphereReflectionCaptureComponent
UStaticMesh* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UStreamableRenderAsset
UStaticMeshPtr* = ptr UStaticMesh
UStaticMeshSocket* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UStaticMeshSocketPtr* = ptr UStaticMeshSocket
UStereoLayerShape* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UStereoLayerShapePtr* = ptr UStereoLayerShape
UStereoLayerShapeCylinder* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UStereoLayerShape
UStereoLayerShapeCylinderPtr* = ptr UStereoLayerShapeCylinder
UStereoLayerShapeEquirect* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UStereoLayerShape
UStereoLayerShapeEquirectPtr* = ptr UStereoLayerShapeEquirect
UStereoLayerComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USceneComponent
UStereoLayerComponentPtr* = ptr UStereoLayerComponent
USubUVAnimation* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
USubUVAnimationPtr* = ptr USubUVAnimation
ATextRenderActor* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AActor
ATextRenderActorPtr* = ptr ATextRenderActor
UTextRenderComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UPrimitiveComponent
UTextRenderComponentPtr* = ptr UTextRenderComponent
UTextureRenderTarget* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UTexture
UTextureRenderTargetPtr* = ptr UTextureRenderTarget
UTextureRenderTarget2D* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UTextureRenderTarget
UTextureRenderTarget2DPtr* = ptr UTextureRenderTarget2D
UTimelineComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UActorComponent
UTimelineComponentPtr* = ptr UTimelineComponent
ATriggerBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AActor
ATriggerBasePtr* = ptr ATriggerBase
UVectorField* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UVectorFieldPtr* = ptr UVectorField
UVectorFieldAnimated* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UVectorField
UVectorFieldAnimatedPtr* = ptr UVectorFieldAnimated
UVectorFieldComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UPrimitiveComponent
UVectorFieldComponentPtr* = ptr UVectorFieldComponent
UVectorFieldStatic* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UVectorField
UVectorFieldStaticPtr* = ptr UVectorFieldStatic
UVisualLoggerDebugSnapshotInterface* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UInterface
UVisualLoggerDebugSnapshotInterfacePtr* = ptr UVisualLoggerDebugSnapshotInterface
UWindDirectionalSourceComponent* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of USceneComponent
UWindDirectionalSourceComponentPtr* = ptr UWindDirectionalSourceComponent
UWorldPartitionRuntimeCellOwner* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UInterface
UWorldPartitionRuntimeCellOwnerPtr* = ptr UWorldPartitionRuntimeCellOwner
UHierarchicalLODSetup* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UHierarchicalLODSetupPtr* = ptr UHierarchicalLODSetup
UTexture2DArray* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UTexture
UTexture2DArrayPtr* = ptr UTexture2DArray
ULevel* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
ULevelPtr* = ptr ULevel
UNullNavSysConfig* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UNullNavSysConfigPtr* = ptr UNullNavSysConfig
UAvoidanceManager* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UAvoidanceManagerPtr* = ptr UAvoidanceManager
AAmbientSound* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AActor
AAmbientSoundPtr* = ptr AAmbientSound
UAimOffsetBlendSpace* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlendSpace
UAimOffsetBlendSpacePtr* = ptr UAimOffsetBlendSpace
UBlendSpace1D* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlendSpace
UBlendSpace1DPtr* = ptr UBlendSpace1D
UAimOffsetBlendSpace1D* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlendSpace1D
UAimOffsetBlendSpace1DPtr* = ptr UAimOffsetBlendSpace1D
UAnimationSettings* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UDeveloperSettings
UAnimationSettingsPtr* = ptr UAnimationSettings
UAnimBoneCompressionCodec* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UAnimBoneCompressionCodecPtr* = ptr UAnimBoneCompressionCodec
UAnimClassInterface* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
UAnimClassInterfacePtr* = ptr UAnimClassInterface
UAnimCompositeBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UAnimSequenceBase
UAnimCompositeBasePtr* = ptr UAnimCompositeBase
UAnimComposite* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UAnimCompositeBase
UAnimCompositePtr* = ptr UAnimComposite
UAnimCompress* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UAnimBoneCompressionCodec
UAnimCompressPtr* = ptr UAnimCompress
UAnimCompress_BitwiseCompressOnly* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UAnimCompress
UAnimCompress_BitwiseCompressOnlyPtr* = ptr UAnimCompress_BitwiseCompressOnly
UAnimCompress_RemoveLinearKeys* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UAnimCompress
UAnimCompress_RemoveLinearKeysPtr* = ptr UAnimCompress_RemoveLinearKeys
UAnimCompress_RemoveEverySecondKey* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UAnimCompress
UAnimCompress_RemoveEverySecondKeyPtr* = ptr UAnimCompress_RemoveEverySecondKey
UAnimCompress_RemoveTrivialKeys* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UAnimCompress
UAnimCompress_RemoveTrivialKeysPtr* = ptr UAnimCompress_RemoveTrivialKeys
UAnimCurveCompressionCodec* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UAnimCurveCompressionCodecPtr* = ptr UAnimCurveCompressionCodec
UAnimDataModel* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UAnimDataModelPtr* = ptr UAnimDataModel
UAnimMetaData* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UAnimMetaDataPtr* = ptr UAnimMetaData
UAnimMontage* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UAnimCompositeBase
UAnimMontagePtr* = ptr UAnimMontage
UAnimNotifyLibrary* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UAnimNotifyLibraryPtr* = ptr UAnimNotifyLibrary
UAnimNotifyMirrorInspectionLibrary* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UAnimNotifyMirrorInspectionLibraryPtr* = ptr UAnimNotifyMirrorInspectionLibrary
UAnimNotifyStateMachineInspectionLibrary* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UAnimNotifyStateMachineInspectionLibraryPtr* = ptr UAnimNotifyStateMachineInspectionLibrary
UAnimNotifyState_DisableRootMotion* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UAnimNotifyState
UAnimNotifyState_DisableRootMotionPtr* = ptr UAnimNotifyState_DisableRootMotion
UAnimNotifyState_TimedParticleEffect* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UAnimNotifyState
UAnimNotifyState_TimedParticleEffectPtr* = ptr UAnimNotifyState_TimedParticleEffect
UAnimNotifyState_Trail* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UAnimNotifyState
UAnimNotifyState_TrailPtr* = ptr UAnimNotifyState_Trail
UAnimSequence* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UAnimSequenceBase
UAnimSequencePtr* = ptr UAnimSequence
UAnimSet* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UAnimSetPtr* = ptr UAnimSet
UAnimStreamable* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UAnimSequenceBase
UAnimStreamablePtr* = ptr UAnimStreamable
UAssetMappingTable* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UAssetMappingTablePtr* = ptr UAssetMappingTable
UAnimationAttributeIdentifierExtensions* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UAnimationAttributeIdentifierExtensionsPtr* = ptr UAnimationAttributeIdentifierExtensions
USkeleton* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
USkeletonPtr* = ptr USkeleton
UBoneMaskFilter* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UBoneMaskFilterPtr* = ptr UBoneMaskFilter
UCachedAnimDataLibrary* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UCachedAnimDataLibraryPtr* = ptr UCachedAnimDataLibrary
UAnimationCurveIdentifierExtensions* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UAnimationCurveIdentifierExtensionsPtr* = ptr UAnimationCurveIdentifierExtensions
UCurveSourceInterface* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
UCurveSourceInterfacePtr* = ptr UCurveSourceInterface
UDataTable* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UDataTablePtr* = ptr UDataTable
UMirrorDataTable* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UDataTable
UMirrorDataTablePtr* = ptr UMirrorDataTable
UNodeMappingContainer* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UNodeMappingContainerPtr* = ptr UNodeMappingContainer
UNodeMappingProviderInterface* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
UNodeMappingProviderInterfacePtr* = ptr UNodeMappingProviderInterface
UPoseAsset* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UAnimationAsset
UPoseAssetPtr* = ptr UPoseAsset
UPreviewCollectionInterface* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
UPreviewCollectionInterfacePtr* = ptr UPreviewCollectionInterface
UPreviewMeshCollection* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UDataAsset
UPreviewMeshCollectionPtr* = ptr UPreviewMeshCollection
URig* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
URigPtr* = ptr URig
UAnimBlueprint* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UAnimBlueprintPtr* = ptr UAnimBlueprint
UAsyncActionLoadPrimaryAssetBase* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UBlueprintAsyncActionBase
UAsyncActionLoadPrimaryAssetBasePtr* = ptr UAsyncActionLoadPrimaryAssetBase
UAsyncActionLoadPrimaryAsset* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UAsyncActionLoadPrimaryAssetBase
UAsyncActionLoadPrimaryAssetPtr* = ptr UAsyncActionLoadPrimaryAsset
UAsyncActionLoadPrimaryAssetClass* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UAsyncActionLoadPrimaryAssetBase
UAsyncActionLoadPrimaryAssetClassPtr* = ptr UAsyncActionLoadPrimaryAssetClass
UAsyncActionLoadPrimaryAssetList* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UAsyncActionLoadPrimaryAssetBase
UAsyncActionLoadPrimaryAssetListPtr* = ptr UAsyncActionLoadPrimaryAssetList
UAsyncActionLoadPrimaryAssetClassList* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UAsyncActionLoadPrimaryAssetBase
UAsyncActionLoadPrimaryAssetClassListPtr* = ptr UAsyncActionLoadPrimaryAssetClassList
UAsyncActionChangePrimaryAssetBundles* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UAsyncActionLoadPrimaryAssetBase
UAsyncActionChangePrimaryAssetBundlesPtr* = ptr UAsyncActionChangePrimaryAssetBundles
AAtmosphericFog* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AInfo
AAtmosphericFogPtr* = ptr AAtmosphericFog
USkyAtmosphereComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USceneComponent
USkyAtmosphereComponentPtr* = ptr USkyAtmosphereComponent
UAtmosphericFogComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USkyAtmosphereComponent
UAtmosphericFogComponentPtr* = ptr UAtmosphericFogComponent
UAudioBus* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UAudioBusPtr* = ptr UAudioBus
AAudioVolume* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AVolume
AAudioVolumePtr* = ptr AAudioVolume
UActorSoundParameterInterface* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
UActorSoundParameterInterfacePtr* = ptr UActorSoundParameterInterface
USoundParameterControllerInterface* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UAudioParameterControllerInterface
USoundParameterControllerInterfacePtr* = ptr USoundParameterControllerInterface
UAudioParameterConversionStatics* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UAudioParameterConversionStaticsPtr* = ptr UAudioParameterConversionStatics
ABlockingVolume* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AVolume
ABlockingVolumePtr* = ptr ABlockingVolume
UBlueprintMapLibrary* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UBlueprintMapLibraryPtr* = ptr UBlueprintMapLibrary
UBlueprintSetLibrary* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UBlueprintSetLibraryPtr* = ptr UBlueprintSetLibrary
UBookMark* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBookmarkBase
UBookMarkPtr* = ptr UBookMark
ABrushShape* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AActor
ABrushShapePtr* = ptr ABrushShape
UCameraLensEffectInterface* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
UCameraLensEffectInterfacePtr* = ptr UCameraLensEffectInterface
UCameraLensEffectInterfaceClassSupportLibrary* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UCameraLensEffectInterfaceClassSupportLibraryPtr* = ptr UCameraLensEffectInterfaceClassSupportLibrary
UCameraModifier* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UCameraModifierPtr* = ptr UCameraModifier
UCameraShakeBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UCameraShakeBasePtr* = ptr UCameraShakeBase
UCameraShakePattern* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UCameraShakePatternPtr* = ptr UCameraShakePattern
UCameraShakeSourceComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USceneComponent
UCameraShakeSourceComponentPtr* = ptr UCameraShakeSourceComponent
UCanvasRenderTarget2D* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UTextureRenderTarget2D
UCanvasRenderTarget2DPtr* = ptr UCanvasRenderTarget2D
UCheatManager* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UCheatManagerPtr* = ptr UCheatManager
UCheatManagerExtension* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UCheatManagerExtensionPtr* = ptr UCheatManagerExtension
UCollisionProfile* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UDeveloperSettings
UCollisionProfilePtr* = ptr UCollisionProfile
UApplicationLifecycleComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UActorComponent
UApplicationLifecycleComponentPtr* = ptr UApplicationLifecycleComponent
UArrowComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UPrimitiveComponent
UArrowComponentPtr* = ptr UArrowComponent
UInitialActiveSoundParams* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UInitialActiveSoundParamsPtr* = ptr UInitialActiveSoundParams
UBillboardComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UPrimitiveComponent
UBillboardComponentPtr* = ptr UBillboardComponent
UBoundsCopyComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UActorComponent
UBoundsCopyComponentPtr* = ptr UBoundsCopyComponent
UShapeComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UPrimitiveComponent
UShapeComponentPtr* = ptr UShapeComponent
UBoxComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UShapeComponent
UBoxComponentPtr* = ptr UBoxComponent
UBrushComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UPrimitiveComponent
UBrushComponentPtr* = ptr UBrushComponent
UCapsuleComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UShapeComponent
UCapsuleComponentPtr* = ptr UCapsuleComponent
UMovementComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UActorComponent
UMovementComponentPtr* = ptr UMovementComponent
UNavMovementComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMovementComponent
UNavMovementComponentPtr* = ptr UNavMovementComponent
UPawnMovementComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UNavMovementComponent
UPawnMovementComponentPtr* = ptr UPawnMovementComponent
UCharacterMovementComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UPawnMovementComponent
UCharacterMovementComponentPtr* = ptr UCharacterMovementComponent
UChildActorComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USceneComponent
UChildActorComponentPtr* = ptr UChildActorComponent
UDecalComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USceneComponent
UDecalComponentPtr* = ptr UDecalComponent
ULightComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of ULightComponentBase
ULightComponentPtr* = ptr ULightComponent
UDirectionalLightComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of ULightComponent
UDirectionalLightComponentPtr* = ptr UDirectionalLightComponent
UDrawFrustumComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UPrimitiveComponent
UDrawFrustumComponentPtr* = ptr UDrawFrustumComponent
USphereComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UShapeComponent
USphereComponentPtr* = ptr USphereComponent
UDrawSphereComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USphereComponent
UDrawSphereComponentPtr* = ptr UDrawSphereComponent
UForceFeedbackComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USceneComponent
UForceFeedbackComponentPtr* = ptr UForceFeedbackComponent
UInterpToMovementComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMovementComponent
UInterpToMovementComponentPtr* = ptr UInterpToMovementComponent
ULineBatchComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UPrimitiveComponent
ULineBatchComponentPtr* = ptr ULineBatchComponent
ULocalLightComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of ULightComponent
ULocalLightComponentPtr* = ptr ULocalLightComponent
ULODSyncComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UActorComponent
ULODSyncComponentPtr* = ptr ULODSyncComponent
UMaterialBillboardComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UPrimitiveComponent
UMaterialBillboardComponentPtr* = ptr UMaterialBillboardComponent
UModelComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UPrimitiveComponent
UModelComponentPtr* = ptr UModelComponent
UPawnNoiseEmitterComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UActorComponent
UPawnNoiseEmitterComponentPtr* = ptr UPawnNoiseEmitterComponent
UPlatformEventsComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UActorComponent
UPlatformEventsComponentPtr* = ptr UPlatformEventsComponent
UPointLightComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of ULocalLightComponent
UPointLightComponentPtr* = ptr UPointLightComponent
UPoseableMeshComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USkinnedMeshComponent
UPoseableMeshComponentPtr* = ptr UPoseableMeshComponent
UPostProcessComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USceneComponent
UPostProcessComponentPtr* = ptr UPostProcessComponent
UProjectileMovementComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMovementComponent
UProjectileMovementComponentPtr* = ptr UProjectileMovementComponent
URectLightComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of ULocalLightComponent
URectLightComponentPtr* = ptr URectLightComponent
URotatingMovementComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMovementComponent
URotatingMovementComponentPtr* = ptr URotatingMovementComponent
URuntimeVirtualTextureComponent* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of USceneComponent
URuntimeVirtualTextureComponentPtr* = ptr URuntimeVirtualTextureComponent
ASkyAtmosphere* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AInfo
ASkyAtmospherePtr* = ptr ASkyAtmosphere
USplineMetadata* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
USplineMetadataPtr* = ptr USplineMetadata
USplineComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UPrimitiveComponent
USplineComponentPtr* = ptr USplineComponent
USplineMeshComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UStaticMeshComponent
USplineMeshComponentPtr* = ptr USplineMeshComponent
USpotLightComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UPointLightComponent
USpotLightComponentPtr* = ptr USpotLightComponent
UVolumetricCloudComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USceneComponent
UVolumetricCloudComponentPtr* = ptr UVolumetricCloudComponent
AVolumetricCloud* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AInfo
AVolumetricCloudPtr* = ptr AVolumetricCloud
UWorldPartitionStreamingSourceComponent* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UActorComponent
UWorldPartitionStreamingSourceComponentPtr* = ptr UWorldPartitionStreamingSourceComponent
UCurveTable* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UCurveTablePtr* = ptr UCurveTable
UCompositeCurveTable* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UCurveTable
UCompositeCurveTablePtr* = ptr UCompositeCurveTable
UCompositeDataTable* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UDataTable
UCompositeDataTablePtr* = ptr UCompositeDataTable
ACullDistanceVolume* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AVolume
ACullDistanceVolumePtr* = ptr ACullDistanceVolume
UCurveBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UCurveBasePtr* = ptr UCurveBase
UCurveFloat* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UCurveBase
UCurveFloatPtr* = ptr UCurveFloat
UCurveLinearColor* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UCurveBase
UCurveLinearColorPtr* = ptr UCurveLinearColor
UCurveLinearColorAtlas* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UTexture2D
UCurveLinearColorAtlasPtr* = ptr UCurveLinearColorAtlas
UCurveVector* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UCurveBase
UCurveVectorPtr* = ptr UCurveVector
UDamageType* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UDamageTypePtr* = ptr UDamageType
UPrimaryDataAsset* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UDataAsset
UPrimaryDataAssetPtr* = ptr UPrimaryDataAsset
UDataTableFunctionLibrary* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UDataTableFunctionLibraryPtr* = ptr UDataTableFunctionLibrary
ADebugCameraController* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of APlayerController
ADebugCameraControllerPtr* = ptr ADebugCameraController
AHUD* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AActor
AHUDPtr* = ptr AHUD
UReporterBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UReporterBasePtr* = ptr UReporterBase
ADecalActor* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AActor
ADecalActorPtr* = ptr ADecalActor
ADefaultPawn* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of APawn
ADefaultPawnPtr* = ptr ADefaultPawn
ADefaultPhysicsVolume* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AVolume
ADefaultPhysicsVolumePtr* = ptr ADefaultPhysicsVolume
UNetDriver* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UNetDriverPtr* = ptr UNetDriver
UDestructibleInterface* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
UDestructibleInterfacePtr* = ptr UDestructibleInterface
UDialogueVoice* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UDialogueVoicePtr* = ptr UDialogueVoice
UDialogueWave* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UDialogueWavePtr* = ptr UDialogueWave
UDPICustomScalingRule* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UDPICustomScalingRulePtr* = ptr UDPICustomScalingRule
UEdGraphNode_Documentation* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UEdGraphNode_DocumentationPtr* = ptr UEdGraphNode_Documentation
UEngineElementsLibrary* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UEngineElementsLibraryPtr* = ptr UEngineElementsLibrary
UTypedElementCommonActions* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UTypedElementCommonActionsPtr* = ptr UTypedElementCommonActions
UTypedElementWorldInterface* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
UTypedElementWorldInterfacePtr* = ptr UTypedElementWorldInterface
ULocalMessage* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
ULocalMessagePtr* = ptr ULocalMessage
UEngineMessage* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of ULocalMessage
UEngineMessagePtr* = ptr UEngineMessage
UCancellableAsyncAction* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintAsyncActionBase
UCancellableAsyncActionPtr* = ptr UCancellableAsyncAction
ULODSyncInterface* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
ULODSyncInterfacePtr* = ptr ULODSyncInterface
AServerStatReplicator* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AInfo
AServerStatReplicatorPtr* = ptr AServerStatReplicator
USystemTimeTimecodeProvider* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UTimecodeProvider
USystemTimeTimecodeProviderPtr* = ptr USystemTimeTimecodeProvider
UViewportStatsSubsystem* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UWorldSubsystem
UViewportStatsSubsystemPtr* = ptr UViewportStatsSubsystem
UFloatingPawnMovement* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UPawnMovementComponent
UFloatingPawnMovementPtr* = ptr UFloatingPawnMovement
UFont* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UFontPtr* = ptr UFont
UFontFace* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UFontFacePtr* = ptr UFontFace
UAsyncActionHandleSaveGame* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintAsyncActionBase
UAsyncActionHandleSaveGamePtr* = ptr UAsyncActionHandleSaveGame
UForceFeedbackEffect* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UForceFeedbackEffectPtr* = ptr UForceFeedbackEffect
USaveGame* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
USaveGamePtr* = ptr USaveGame
USpringArmComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USceneComponent
USpringArmComponentPtr* = ptr USpringArmComponent
UTouchInterface* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UTouchInterfacePtr* = ptr UTouchInterface
UGameplayStatics* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UGameplayStaticsPtr* = ptr UGameplayStatics
UGameUserSettings* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UGameUserSettingsPtr* = ptr UGameUserSettings
UImportantToggleSettingInterface* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UInterface
UImportantToggleSettingInterfacePtr* = ptr UImportantToggleSettingInterface
UInputDelegateBinding* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UDynamicBlueprintBinding
UInputDelegateBindingPtr* = ptr UInputDelegateBinding
UInterpCurveEdSetup* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UInterpCurveEdSetupPtr* = ptr UInterpCurveEdSetup
UKismetArrayLibrary* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UKismetArrayLibraryPtr* = ptr UKismetArrayLibrary
UKismetGuidLibrary* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UKismetGuidLibraryPtr* = ptr UKismetGuidLibrary
UKismetInputLibrary* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UKismetInputLibraryPtr* = ptr UKismetInputLibrary
UKismetInternationalizationLibrary* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UKismetInternationalizationLibraryPtr* = ptr UKismetInternationalizationLibrary
UKismetMaterialLibrary* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UKismetMaterialLibraryPtr* = ptr UKismetMaterialLibrary
UKismetMathLibrary* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UKismetMathLibraryPtr* = ptr UKismetMathLibrary
UKismetNodeHelperLibrary* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UKismetNodeHelperLibraryPtr* = ptr UKismetNodeHelperLibrary
UKismetRenderingLibrary* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UKismetRenderingLibraryPtr* = ptr UKismetRenderingLibrary
UKismetStringLibrary* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UKismetStringLibraryPtr* = ptr UKismetStringLibrary
UKismetStringTableLibrary* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UKismetStringTableLibraryPtr* = ptr UKismetStringTableLibrary
UKismetSystemLibrary* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UKismetSystemLibraryPtr* = ptr UKismetSystemLibrary
UBlueprintPathsLibrary* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UBlueprintPathsLibraryPtr* = ptr UBlueprintPathsLibrary
UPlatformGameInstance* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UGameInstance
UPlatformGameInstancePtr* = ptr UPlatformGameInstance
UBlueprintPlatformLibrary* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UBlueprintPlatformLibraryPtr* = ptr UBlueprintPlatformLibrary
UImportanceSamplingLibrary* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UImportanceSamplingLibraryPtr* = ptr UImportanceSamplingLibrary
ULevelPartitionInterface* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
ULevelPartitionInterfacePtr* = ptr ULevelPartitionInterface
ULevelActorContainer* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
ULevelActorContainerPtr* = ptr ULevelActorContainer
ULevelStreamingLevelInstanceEditor* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of ULevelStreamingAlwaysLoaded
ULevelStreamingLevelInstanceEditorPtr* = ptr ULevelStreamingLevelInstanceEditor
ULevelInstanceInterface* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
ULevelInstanceInterfacePtr* = ptr ULevelInstanceInterface
ALevelScriptActor* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AActor
ALevelScriptActorPtr* = ptr ALevelScriptActor
ULevelScriptBlueprint* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
ULevelScriptBlueprintPtr* = ptr ULevelScriptBlueprint
ULightmappedSurfaceCollection* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
ULightmappedSurfaceCollectionPtr* = ptr ULightmappedSurfaceCollection
ALightmassCharacterIndirectDetailVolume* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of AVolume
ALightmassCharacterIndirectDetailVolumePtr* = ptr ALightmassCharacterIndirectDetailVolume
ALightmassImportanceVolume* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AVolume
ALightmassImportanceVolumePtr* = ptr ALightmassImportanceVolume
ULightmassPrimitiveSettingsObject* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UObject
ULightmassPrimitiveSettingsObjectPtr* = ptr ULightmassPrimitiveSettingsObject
ULightWeightInstanceBlueprintFunctionLibrary* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
ULightWeightInstanceBlueprintFunctionLibraryPtr* = ptr ULightWeightInstanceBlueprintFunctionLibrary
ALightWeightInstanceManager* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AActor
ALightWeightInstanceManagerPtr* = ptr ALightWeightInstanceManager
ALightWeightInstanceStaticMeshManager* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of ALightWeightInstanceManager
ALightWeightInstanceStaticMeshManagerPtr* = ptr ALightWeightInstanceStaticMeshManager
ALocationVolume* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AVolume
ALocationVolumePtr* = ptr ALocationVolume
AMaterialInstanceActor* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AActor
AMaterialInstanceActorPtr* = ptr AMaterialInstanceActor
UMaterialInstanceEditorOnlyData* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UObject
UMaterialInstanceEditorOnlyDataPtr* = ptr UMaterialInstanceEditorOnlyData
UMaterialInstanceDynamic* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UMaterialInstance
UMaterialInstanceDynamicPtr* = ptr UMaterialInstanceDynamic
AMeshMergeCullingVolume* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AVolume
AMeshMergeCullingVolumePtr* = ptr AMeshMergeCullingVolume
UMeshVertexPainterKismetLibrary* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UMeshVertexPainterKismetLibraryPtr* = ptr UMeshVertexPainterKismetLibrary
ANavigationObjectBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AActor
ANavigationObjectBasePtr* = ptr ANavigationObjectBase
UNetPushModelHelpers* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UNetPushModelHelpersPtr* = ptr UNetPushModelHelpers
ANote* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AActor
ANotePtr* = ptr ANote
UObjectLibrary* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UObjectLibraryPtr* = ptr UObjectLibrary
UOnlineBlueprintCallProxyBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintAsyncActionBase
UOnlineBlueprintCallProxyBasePtr* = ptr UOnlineBlueprintCallProxyBase
UAsyncPhysicsInputComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UActorComponent
UAsyncPhysicsInputComponentPtr* = ptr UAsyncPhysicsInputComponent
UBodySetup* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UBodySetupPtr* = ptr UBodySetup
UConstraintInstanceBlueprintLibrary* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UConstraintInstanceBlueprintLibraryPtr* = ptr UConstraintInstanceBlueprintLibrary
UPhysicalAnimationComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UActorComponent
UPhysicalAnimationComponentPtr* = ptr UPhysicalAnimationComponent
UPhysicalMaterialMask* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UPhysicalMaterialMaskPtr* = ptr UPhysicalMaterialMask
UPhysicsAsset* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UPhysicsAssetPtr* = ptr UPhysicsAsset
USkeletalBodySetup* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBodySetup
USkeletalBodySetupPtr* = ptr USkeletalBodySetup
UPhysicsCollisionHandler* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UPhysicsCollisionHandlerPtr* = ptr UPhysicsCollisionHandler
APhysicsConstraintActor* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of ARigidBodyBase
APhysicsConstraintActorPtr* = ptr APhysicsConstraintActor
UPhysicsConstraintComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USceneComponent
UPhysicsConstraintComponentPtr* = ptr UPhysicsConstraintComponent
UPhysicsConstraintTemplate* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UPhysicsConstraintTemplatePtr* = ptr UPhysicsConstraintTemplate
UPhysicsHandleComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UActorComponent
UPhysicsHandleComponentPtr* = ptr UPhysicsHandleComponent
URadialForceComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USceneComponent
URadialForceComponentPtr* = ptr URadialForceComponent
UPhysicsFieldComponent* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USceneComponent
UPhysicsFieldComponentPtr* = ptr UPhysicsFieldComponent
UPlatformInputDeviceMapperLibrary* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UPlatformInputDeviceMapperLibraryPtr* = ptr UPlatformInputDeviceMapperLibrary
APlayerStart* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of ANavigationObjectBase
APlayerStartPtr* = ptr APlayerStart
APlayerStartPIE* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of APlayerStart
APlayerStartPIEPtr* = ptr APlayerStartPIE
APlayerState* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AInfo
APlayerStatePtr* = ptr APlayerState
APostProcessVolume* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AVolume
APostProcessVolumePtr* = ptr APostProcessVolume
APrecomputedVisibilityVolume* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AVolume
APrecomputedVisibilityVolumePtr* = ptr APrecomputedVisibilityVolume
UHealthSnapshotBlueprintLibrary* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UHealthSnapshotBlueprintLibraryPtr* = ptr UHealthSnapshotBlueprintLibrary
ARectLight* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of ALight
ARectLightPtr* = ptr ARectLight
USubsurfaceProfile* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
USubsurfaceProfilePtr* = ptr USubsurfaceProfile
UReplaySubsystem* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UGameInstanceSubsystem
UReplaySubsystemPtr* = ptr UReplaySubsystem
UReverbEffect* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UReverbEffectPtr* = ptr UReverbEffect
URuntimeOptionsBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
URuntimeOptionsBasePtr* = ptr URuntimeOptionsBase
USCS_Node* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
USCS_NodePtr* = ptr USCS_Node
USimpleConstructionScript* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
USimpleConstructionScriptPtr* = ptr USimpleConstructionScript
USkeletalMesh* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USkinnedAsset
USkeletalMeshPtr* = ptr USkeletalMesh
USkeletalMeshLODSettings* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UDataAsset
USkeletalMeshLODSettingsPtr* = ptr USkeletalMeshLODSettings
UButtonStyleAsset* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UButtonStyleAssetPtr* = ptr UButtonStyleAsset
UCheckBoxStyleAsset* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UCheckBoxStyleAssetPtr* = ptr UCheckBoxStyleAsset
USlateBrushAsset* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
USlateBrushAssetPtr* = ptr USlateBrushAsset
USlateTextureAtlasInterface* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UInterface
USlateTextureAtlasInterfacePtr* = ptr USlateTextureAtlasInterface
USoundClass* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
USoundClassPtr* = ptr USoundClass
USoundConcurrency* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
USoundConcurrencyPtr* = ptr USoundConcurrency
USoundCue* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundBase
USoundCuePtr* = ptr USoundCue
USoundMix* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
USoundMixPtr* = ptr USoundMix
USoundNodeAssetReferencer* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundNode
USoundNodeAssetReferencerPtr* = ptr USoundNodeAssetReferencer
USoundNodeAttenuation* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundNode
USoundNodeAttenuationPtr* = ptr USoundNodeAttenuation
USoundNodeBranch* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundNode
USoundNodeBranchPtr* = ptr USoundNodeBranch
USoundNodeConcatenator* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundNode
USoundNodeConcatenatorPtr* = ptr USoundNodeConcatenator
USoundNodeDelay* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundNode
USoundNodeDelayPtr* = ptr USoundNodeDelay
USoundNodeDialoguePlayer* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundNode
USoundNodeDialoguePlayerPtr* = ptr USoundNodeDialoguePlayer
USoundNodeDistanceCrossFade* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundNode
USoundNodeDistanceCrossFadePtr* = ptr USoundNodeDistanceCrossFade
USoundNodeEnveloper* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundNode
USoundNodeEnveloperPtr* = ptr USoundNodeEnveloper
USoundNodeGroupControl* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundNode
USoundNodeGroupControlPtr* = ptr USoundNodeGroupControl
USoundNodeLooping* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundNode
USoundNodeLoopingPtr* = ptr USoundNodeLooping
USoundNodeMature* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundNode
USoundNodeMaturePtr* = ptr USoundNodeMature
USoundNodeMixer* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundNode
USoundNodeMixerPtr* = ptr USoundNodeMixer
USoundNodeModulator* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundNode
USoundNodeModulatorPtr* = ptr USoundNodeModulator
USoundNodeParamCrossFade* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundNodeDistanceCrossFade
USoundNodeParamCrossFadePtr* = ptr USoundNodeParamCrossFade
USoundNodeQualityLevel* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundNode
USoundNodeQualityLevelPtr* = ptr USoundNodeQualityLevel
USoundNodeRandom* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundNode
USoundNodeRandomPtr* = ptr USoundNodeRandom
USoundNodeSoundClass* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundNode
USoundNodeSoundClassPtr* = ptr USoundNodeSoundClass
USoundNodeSwitch* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundNode
USoundNodeSwitchPtr* = ptr USoundNodeSwitch
USoundNodeWaveParam* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundNode
USoundNodeWaveParamPtr* = ptr USoundNodeWaveParam
USoundNodeWavePlayer* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundNodeAssetReferencer
USoundNodeWavePlayerPtr* = ptr USoundNodeWavePlayer
USoundSourceBus* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundWave
USoundSourceBusPtr* = ptr USoundSourceBus
USoundSubmixBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
USoundSubmixBasePtr* = ptr USoundSubmixBase
USoundSubmixWithParentBase* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundSubmixBase
USoundSubmixWithParentBasePtr* = ptr USoundSubmixWithParentBase
USoundSubmix* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundSubmixWithParentBase
USoundSubmixPtr* = ptr USoundSubmix
USoundfieldSubmix* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundSubmixWithParentBase
USoundfieldSubmixPtr* = ptr USoundfieldSubmix
UEndpointSubmix* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundSubmixBase
UEndpointSubmixPtr* = ptr UEndpointSubmix
USoundfieldEndpointSubmix* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USoundSubmixBase
USoundfieldEndpointSubmixPtr* = ptr USoundfieldEndpointSubmix
ASpectatorPawn* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of ADefaultPawn
ASpectatorPawnPtr* = ptr ASpectatorPawn
UStereoLayerFunctionLibrary* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UStereoLayerFunctionLibraryPtr* = ptr UStereoLayerFunctionLibrary
UTextureMipDataProviderFactory* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UAssetUserData
UTextureMipDataProviderFactoryPtr* = ptr UTextureMipDataProviderFactory
UAudioEngineSubsystem* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UDynamicSubsystem
UAudioEngineSubsystemPtr* = ptr UAudioEngineSubsystem
ULocalPlayerSubsystem* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of USubsystem
ULocalPlayerSubsystemPtr* = ptr ULocalPlayerSubsystem
USubsystemBlueprintLibrary* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
USubsystemBlueprintLibraryPtr* = ptr USubsystemBlueprintLibrary
ATargetPoint* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AActor
ATargetPointPtr* = ptr ATargetPoint
UTexture2DDynamic* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UTexture
UTexture2DDynamicPtr* = ptr UTexture2DDynamic
UTextureCubeArray* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UTexture
UTextureCubeArrayPtr* = ptr UTextureCubeArray
UTextureLightProfile* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UTexture2D
UTextureLightProfilePtr* = ptr UTextureLightProfile
UTextureRenderTarget2DArray* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UTextureRenderTarget
UTextureRenderTarget2DArrayPtr* = ptr UTextureRenderTarget2DArray
UTextureRenderTargetCube* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UTextureRenderTarget
UTextureRenderTargetCubePtr* = ptr UTextureRenderTargetCube
UTextureRenderTargetVolume* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UTextureRenderTarget
UTextureRenderTargetVolumePtr* = ptr UTextureRenderTargetVolume
UTimelineTemplate* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UTimelineTemplatePtr* = ptr UTimelineTemplate
UCanvas* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UCanvasPtr* = ptr UCanvas
UInputSettings* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UInputSettingsPtr* = ptr UInputSettings
AVectorFieldVolume* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AActor
AVectorFieldVolumePtr* = ptr AVectorFieldVolume
UVisualLoggerKismetLibrary* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UVisualLoggerKismetLibraryPtr* = ptr UVisualLoggerKismetLibrary
UVOIPTalker* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UActorComponent
UVOIPTalkerPtr* = ptr UVOIPTalker
UVOIPStatics* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UVOIPStaticsPtr* = ptr UVOIPStatics
UVolumeTexture* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UTexture
UVolumeTexturePtr* = ptr UVolumeTexture
AVolumetricLightmapDensityVolume* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of AVolume
AVolumetricLightmapDensityVolumePtr* = ptr AVolumetricLightmapDensityVolume
URuntimeVirtualTexture* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
URuntimeVirtualTexturePtr* = ptr URuntimeVirtualTexture
ARuntimeVirtualTextureVolume* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of AActor
ARuntimeVirtualTextureVolumePtr* = ptr ARuntimeVirtualTextureVolume
UVirtualTextureBuilder* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UVirtualTextureBuilderPtr* = ptr UVirtualTextureBuilder
UWorldPartitionBlueprintLibrary* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UBlueprintFunctionLibrary
UWorldPartitionBlueprintLibraryPtr* = ptr UWorldPartitionBlueprintLibrary
UDEPRECATED_DataLayer* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UDEPRECATED_DataLayerPtr* = ptr UDEPRECATED_DataLayer
UDataLayerAsset* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UDataLayerAssetPtr* = ptr UDataLayerAsset
UDataLayerInstance* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UDataLayerInstancePtr* = ptr UDataLayerInstance
UDataLayerSubsystem* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UWorldSubsystem
UDataLayerSubsystemPtr* = ptr UDataLayerSubsystem
UHLODLayer* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UHLODLayerPtr* = ptr UHLODLayer
UWorldPartitionActorLoaderInterface* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UInterface
UWorldPartitionActorLoaderInterfacePtr* = ptr UWorldPartitionActorLoaderInterface
UWorldPartitionEditorHash* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UWorldPartitionEditorHashPtr* = ptr UWorldPartitionEditorHash
UWorldPartitionStreamingPolicy* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UWorldPartitionStreamingPolicyPtr* = ptr UWorldPartitionStreamingPolicy
UWorldPartitionRuntimeCell* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UWorldPartitionRuntimeCellPtr* = ptr UWorldPartitionRuntimeCell
URuntimeHashExternalStreamingObjectBase* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UObject
URuntimeHashExternalStreamingObjectBasePtr* = ptr URuntimeHashExternalStreamingObjectBase
UWorldPartitionRuntimeHash* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UObject
UWorldPartitionRuntimeHashPtr* = ptr UWorldPartitionRuntimeHash
UWorldPartitionRuntimeSpatialHashCell* {.importcpp: "$1_",
header: "UEGenClassDefs.h".} = object of UWorldPartitionRuntimeCell
UWorldPartitionRuntimeSpatialHashCellPtr* = ptr UWorldPartitionRuntimeSpatialHashCell
UWorldPartitionSubsystem* {.importcpp: "$1_", header: "UEGenClassDefs.h".} = object of UTickableWorldSubsystem
UWorldPartitionSubsystemPtr* = ptr UWorldPartitionSubsystem
FFloatRK4SpringInterpolator* {.exportcpp: "$1_".} = object
FFormatArgumentData* {.exportcpp: "$1_".} = object
argumentName*: FString
argumentValueType*: EFormatArgumentType
pad_0: array[7, byte]
argumentValue*: FText
argumentValueInt*: int64
argumentValueFloat*: float32
pad_1: array[4, byte]
argumentValueDouble*: float64
argumentValueGender*: ETextGender
ETextGender* {.size: sizeof(uint8), pure.} = enum
Masculine, Feminine, Neuter, ETextGender_MAX
EFormatArgumentType* {.size: sizeof(uint8), pure.} = enum
Int, UInt, Float, Double, Text, Gender, EFormatArgumentType_MAX
FVectorRK4SpringInterpolator* {.exportcpp: "$1_".} = object
FAnimDataModelModifiedDynamicEvent*
{.exportcpp: "$1_".} = object of FMulticastScriptDelegate
FAnimDataModelNotifPayload* {.exportcpp: "$1_".} = object
pad_0: array[16, byte]
EAnimDataModelNotifyType* {.size: sizeof(uint8), pure.} = enum
BracketOpened, BracketClosed, TrackAdded, TrackChanged, TrackRemoved,
SequenceLengthChanged, FrameRateChanged, CurveAdded, CurveChanged,
CurveRemoved, CurveFlagsChanged, CurveRenamed, CurveScaled,
CurveColorChanged, AttributeAdded, AttributeRemoved, AttributeChanged,
Populated, Reset, Invalid, EAnimDataModelNotifyType_MAX
FCharacterMovementUpdatedSignature*
{.exportcpp: "$1_".} = object of FMulticastScriptDelegate
FCharacterReachedApexSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FConstraintBrokenSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FEmptyOnlineDelegate* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FInputActionHandlerDynamicSignature*
{.exportcpp: "$1_".} = object of FScriptDelegate
FInputAxisHandlerDynamicSignature*
{.exportcpp: "$1_".} = object of FScriptDelegate
FInputGestureHandlerDynamicSignature*
{.exportcpp: "$1_".} = object of FScriptDelegate
FInputTouchHandlerDynamicSignature*
{.exportcpp: "$1_".} = object of FScriptDelegate
FInputVectorAxisHandlerDynamicSignature*
{.exportcpp: "$1_".} = object of FScriptDelegate
FInstigatedAnyDamageSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FLandedSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FLevelStreamingLoadedStatus* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FLevelStreamingVisibilityStatus*
{.exportcpp: "$1_".} = object of FMulticastScriptDelegate
FMovementModeChangedSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
EMovementMode* {.size: sizeof(uint8), pure.} = enum
MOVE_None, MOVE_Walking, MOVE_NavWalking, MOVE_Falling, MOVE_Swimming,
MOVE_Flying, MOVE_Custom, MOVE_MAX
FOnActorReady* {.exportcpp: "$1_".} = object of
FScriptDelegate
FOnAllMontageInstancesEndedMCDelegate*
{.exportcpp: "$1_".} = object of FMulticastScriptDelegate
FOnAnimInitialized* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnAsyncHandleSaveGame* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnAudioFadeChangeSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnAudioFinished* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnAudioMultiEnvelopeValue* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnAudioPlaybackPercent* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnAudioPlayStateChanged* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
EAudioComponentPlayState* {.size: sizeof(uint8), pure.} = enum
Playing, Stopped, Paused, FadingIn, FadingOut, Count,
EAudioComponentPlayState_MAX
FOnAudioSingleEnvelopeValue* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnAudioVirtualizationChanged* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnBoneTransformsFinalized* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnCanvasRenderTargetUpdate* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnDataLayerRuntimeStateChanged*
{.exportcpp: "$1_".} = object of FMulticastScriptDelegate
EDataLayerRuntimeState* {.size: sizeof(uint8), pure.} = enum
Unloaded, Loaded, Activated, EDataLayerRuntimeState_MAX
FOnForceFeedbackFinished* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnGameUserSettingsUINeedsUpdate*
{.exportcpp: "$1_".} = object of FMulticastScriptDelegate
FOnMontageBlendingOutStartedMCDelegate*
{.exportcpp: "$1_".} = object of FMulticastScriptDelegate
FOnMontageEndedMCDelegate* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnMontageStartedMCDelegate* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnPawnControllerChanged* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnPlayerStatePawnSet* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnPossessedPawnChanged* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnPrimaryAssetBundlesChanged* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnPrimaryAssetClassListLoaded* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnPrimaryAssetClassLoaded* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnPrimaryAssetListLoaded* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnPrimaryAssetLoaded* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnQuartzCommandEvent* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
EQuartzCommandDelegateSubType* {.size: sizeof(uint8), pure.} = enum
CommandOnFailedToQueue, CommandOnQueued, CommandOnCanceled,
CommandOnAboutToStart, CommandOnStarted, Count,
EQuartzCommandDelegateSubType_MAX
FOnQuartzCommandEventBP* {.exportcpp: "$1_".} = object of
FScriptDelegate
FOnQuartzMetronomeEvent* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
EQuartzCommandQuantization* {.size: sizeof(uint8), pure.} = enum
Bar, Beat, ThirtySecondNote, SixteenthNote, EighthNote, QuarterNote,
HalfNote, WholeNote, DottedSixteenthNote, DottedEighthNote,
DottedQuarterNote, DottedHalfNote, DottedWholeNote, SixteenthNoteTriplet,
EighthNoteTriplet, QuarterNoteTriplet, HalfNoteTriplet, Tick, Count, None,
EQuartzCommandQuantization_MAX
FOnQuartzMetronomeEventBP* {.exportcpp: "$1_".} = object of
FScriptDelegate
FOnQueueSubtitles* {.exportcpp: "$1_".} = object of
FScriptDelegate
FSubtitleCue* {.exportcpp: "$1_".} = object
text*: FText
time*: float32
pad_0: array[4, byte]
FOnSubmixEnvelope* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnSubmixEnvelopeBP* {.exportcpp: "$1_".} = object of
FScriptDelegate
FOnSubmixRecordedFileDone* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnSubmixSpectralAnalysis* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnSubmixSpectralAnalysisBP* {.exportcpp: "$1_".} = object of
FScriptDelegate
FOnSystemFinished* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnTimelineEvent* {.exportcpp: "$1_".} = object of
FScriptDelegate
FOnTimelineFloat* {.exportcpp: "$1_".} = object of
FScriptDelegate
FOnTimelineLinearColor* {.exportcpp: "$1_".} = object of
FScriptDelegate
FOnTimelineVector* {.exportcpp: "$1_".} = object of
FScriptDelegate
FOnUserClickedBanner* {.exportcpp: "$1_".} = object of
FScriptDelegate
FOnUserClosedAdvertisement* {.exportcpp: "$1_".} = object of
FScriptDelegate
FOnUserInputDeviceConnectionChange*
{.exportcpp: "$1_".} = object of FMulticastScriptDelegate
FOnUserInputDevicePairingChange*
{.exportcpp: "$1_".} = object of FMulticastScriptDelegate
FParticleBurstSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FParticleCollisionSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FParticleDeathSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FParticleSpawnSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FPlasticDeformationEventSignature*
{.exportcpp: "$1_".} = object of FMulticastScriptDelegate
FPlatformInterfaceDelegate* {.exportcpp: "$1_".} = object of
FScriptDelegate
EPlatformInterfaceDataType* {.size: sizeof(uint8), pure.} = enum
PIDT_None, PIDT_Int, PIDT_Float, PIDT_String, PIDT_Object, PIDT_Custom,
PIDT_MAX
FPlayMontageAnimNotifyDelegate* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FPostEvaluateAnimEvent* {.exportcpp: "$1_".} = object of
FScriptDelegate
FTimerDynamicDelegate* {.exportcpp: "$1_".} = object of
FScriptDelegate
FViewportDisplayCallback* {.exportcpp: "$1_".} = object of
FScriptDelegate
EEndPlayReason* {.size: sizeof(uint8), pure.} = enum
Destroyed, LevelTransition, EndPlayInEditor, RemovedFromWorld, Quit,
EEndPlayReason_MAX
ETickingGroup* {.size: sizeof(uint8), pure.} = enum
TG_PrePhysics, TG_StartPhysics, TG_DuringPhysics, TG_EndPhysics,
TG_PostPhysics, TG_PostUpdateWork, TG_LastDemotable, TG_NewlySpawned, TG_MAX
FActorComponentDeactivateSignature*
{.exportcpp: "$1_".} = object of FMulticastScriptDelegate
FActorComponentActivatedSignature*
{.exportcpp: "$1_".} = object of FMulticastScriptDelegate
EComponentCreationMethod* {.size: sizeof(uint8), pure.} = enum
Native, SimpleConstructionScript, UserConstructionScript, Instance,
EComponentCreationMethod_MAX
ETemperatureSeverityType* {.size: sizeof(uint8), pure.} = enum
Unknown, Good, Bad, Serious, Critical, NumSeverities,
ETemperatureSeverityType_MAX
EPlaneConstraintAxisSetting* {.size: sizeof(uint8), pure.} = enum
Custom, X, Y, Z, UseGlobalPhysicsSetting, EPlaneConstraintAxisSetting_MAX
FInterpControlPoint* {.exportcpp: "$1_".} = object
positionControlPoint*: FVector
bPositionIsRelative*: bool
pad_0: array[15, byte]
EInterpToBehaviourType* {.size: sizeof(uint8), pure.} = enum
OneShot, OneShot_Reverse, Loop_Reset, PingPong, EInterpToBehaviourType_MAX
ETeleportType* {.size: sizeof(uint8), pure.} = enum
None, TeleportPhysics, ResetPhysics, ETeleportType_MAX
FDebugFloatHistory* {.exportcpp: "$1_".} = object
pad_0: array[16, byte]
maxSamples*: int32
minValue*: float32
maxValue*: float32
bAutoAdjustMinMax*: bool
pad_1: array[3, byte]
EDrawDebugTrace* {.size: sizeof(uint8), pure.} = enum
None, ForOneFrame, ForDuration, Persistent, EDrawDebugTrace_MAX
FLatentActionInfo* {.exportcpp: "$1_".} = object
pad_0: array[32, byte]
FTimerHandle* {.exportcpp: "$1_".} = object
pad_0: array[8, byte]
EMoveComponentAction* {.size: sizeof(uint8), pure.} = enum
Move, Stop, Return, EMoveComponentAction_MAX
EQuitPreference* {.size: sizeof(uint8), pure.} = enum
Quit, Background, EQuitPreference_MAX
FCollisionProfileName* {.exportcpp: "$1_".} = object
name*: FName
FGenericStruct* {.exportcpp: "$1_".} = object
pad_0: array[4, byte]
FUserActivity* {.exportcpp: "$1_".} = object
actionName*: FString
pad_0: array[8, byte]
ETravelFailure* {.size: sizeof(uint8), pure.} = enum
NoLevel, LoadMapFailure, InvalidURL, PackageMissing, PackageVersion,
NoDownload, TravelFailure, CheatCommands, PendingNetGameCreateFailure,
CloudSaveFailure, ServerTravelFailure, ClientTravelFailure,
ETravelFailure_MAX
EApplicationState* {.size: sizeof(uint8), pure.} = enum
Unknown, Inactive, Background, Active, EApplicationState_MAX
EScreenOrientation* {.size: sizeof(uint8), pure.} = enum
Unknown, Portrait, PortraitUpsideDown, LandscapeLeft, LandscapeRight,
FaceUp, FaceDown, PortraitSensor, LandscapeSensor, FullSensor,
EScreenOrientation_MAX
FActorBeginCursorOverSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FActorBeginOverlapSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FActorBeginTouchOverSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FActorDestroyedSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FActorEndCursorOverSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FActorEndOverlapSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FActorEndPlaySignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FActorEndTouchOverSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FActorHitSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FActorOnClickedSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FActorOnInputTouchBeginSignature*
{.exportcpp: "$1_".} = object of FMulticastScriptDelegate
FActorOnInputTouchEndSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FActorOnReleasedSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FComponentBeginCursorOverSignature*
{.exportcpp: "$1_".} = object of FMulticastScriptDelegate
FComponentBeginOverlapSignature*
{.exportcpp: "$1_".} = object of FMulticastScriptDelegate
FComponentBeginTouchOverSignature*
{.exportcpp: "$1_".} = object of FMulticastScriptDelegate
FComponentCollisionSettingsChangedSignature*
{.exportcpp: "$1_".} = object of FMulticastScriptDelegate
FComponentEndCursorOverSignature*
{.exportcpp: "$1_".} = object of FMulticastScriptDelegate
FComponentEndOverlapSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FComponentEndTouchOverSignature*
{.exportcpp: "$1_".} = object of FMulticastScriptDelegate
FComponentHitSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FComponentOnClickedSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FComponentOnInputTouchBeginSignature*
{.exportcpp: "$1_".} = object of FMulticastScriptDelegate
FComponentOnInputTouchEndSignature*
{.exportcpp: "$1_".} = object of FMulticastScriptDelegate
FComponentOnReleasedSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FComponentPhysicsStateChanged* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
EComponentPhysicsStateChange* {.size: sizeof(uint8), pure.} = enum
Created, Destroyed, EComponentPhysicsStateChange_MAX
FComponentSleepSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FComponentWakeSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FIsRootComponentChanged* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FPawnControllerChangedSignature*
{.exportcpp: "$1_".} = object of FMulticastScriptDelegate
FPawnRestartedSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FPhysicsVolumeChanged* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FTakeAnyDamageSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FTakePointDamageSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FTakeRadialDamageSignature* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
ERelativeTransformSpace* {.size: sizeof(uint8), pure.} = enum
RTS_World, RTS_Actor, RTS_Component, RTS_ParentBoneSpace, RTS_MAX
EAttachLocation* {.size: sizeof(uint8), pure.} = enum
KeepRelativeOffset, KeepWorldPosition, SnapToTarget,
SnapToTargetIncludingScale, EAttachLocation_MAX
EAttachmentRule* {.size: sizeof(uint8), pure.} = enum
KeepRelative, KeepWorld, SnapToTarget, EAttachmentRule_MAX
EDetachmentRule* {.size: sizeof(uint8), pure.} = enum
KeepRelative, KeepWorld, EDetachmentRule_MAX
EComponentMobility* {.size: sizeof(uint8), pure.} = enum
Static, Stationary, Movable, EComponentMobility_MAX
EDetailMode* {.size: sizeof(uint8), pure.} = enum
DM_Low, DM_Medium, DM_High, DM_MAX
ENavPathEvent* {.size: sizeof(uint8), pure.} = enum
Cleared, NewPath, UpdatedDueToGoalMoved, UpdatedDueToNavigationChanged,
Invalidated, RePathFailed, MetaPathUpdate, Custom, ENavPathEvent_MAX
EMouseLockMode* {.size: sizeof(uint8), pure.} = enum
DoNotLock, LockOnCapture, LockAlways, LockInFullscreen, EMouseLockMode_MAX
EWindowTitleBarMode* {.size: sizeof(uint8), pure.} = enum
Overlay, VerticalBox, EWindowTitleBarMode_MAX
AnimationKeyFormat* {.size: sizeof(uint8), pure.} = enum
AKF_ConstantKeyLerp, AKF_VariableKeyLerp, AKF_PerTrackCompression, AKF_MAX
EAnimAssetCurveFlags* {.size: sizeof(uint8), pure.} = enum
AACF_NONE, AACF_DriveMorphTarget_DEPRECATED, AACF_DriveAttribute_DEPRECATED,
AACF_Editable, AACF_DriveMaterial_DEPRECATED, AACF_Metadata,
AACF_DriveTrack, AACF_Disabled, AACF_MAX
ERawCurveTrackTypes* {.size: sizeof(uint8), pure.} = enum
RCT_Float, RCT_Vector, RCT_Transform, RCT_MAX
ERootMotionRootLock* {.size: sizeof(uint8), pure.} = enum
RefPose, AnimFirstFrame, Zero, ERootMotionRootLock_MAX
ERootMotionMode* {.size: sizeof(uint8), pure.} = enum
NoRootMotionExtraction, IgnoreRootMotion, RootMotionFromEverything,
RootMotionFromMontagesOnly, ERootMotionMode_MAX
EAdditiveBasePoseType* {.size: sizeof(uint8), pure.} = enum
ABPT_None, ABPT_RefPose, ABPT_AnimScaled, ABPT_AnimFrame,
ABPT_LocalAnimFrame, ABPT_MAX
AnimationCompressionFormat* {.size: sizeof(uint8), pure.} = enum
ACF_None, ACF_Float96NoW, ACF_Fixed48NoW, ACF_IntervalFixed32NoW,
ACF_Fixed32NoW, ACF_Float32NoW, ACF_Identity, ACF_MAX
AnimPhysTwistAxis* {.size: sizeof(uint8), pure.} = enum
AxisX, AxisY, AxisZ, AnimPhysTwistAxis_MAX
AnimPhysCollisionType* {.size: sizeof(uint8), pure.} = enum
CoM, CustomSphere, InnerSphere, OuterSphere, AnimPhysCollisionType_MAX
ETypeAdvanceAnim* {.size: sizeof(uint8), pure.} = enum
ETAA_Default, ETAA_Finished, ETAA_Looped, ETAA_MAX
EBoneAxis* {.size: sizeof(uint8), pure.} = enum
BA_X, BA_Y, BA_Z, BA_MAX
EBoneControlSpace* {.size: sizeof(uint8), pure.} = enum
BCS_WorldSpace, BCS_ComponentSpace, BCS_ParentBoneSpace, BCS_BoneSpace,
BCS_MAX
EBoneRotationSource* {.size: sizeof(uint8), pure.} = enum
BRS_KeepComponentSpaceRotation, BRS_KeepLocalSpaceRotation,
BRS_CopyFromTarget, BRS_MAX
EMontageNotifyTickType* {.size: sizeof(uint8), pure.} = enum
Queued, BranchingPoint, EMontageNotifyTickType_MAX
ENotifyFilterType* {.size: sizeof(uint8), pure.} = enum
NoFiltering, LOD, ENotifyFilterType_MAX
EAdditiveAnimationType* {.size: sizeof(uint8), pure.} = enum
AAT_None, AAT_LocalSpaceBase, AAT_RotationOffsetMeshSpace, AAT_MAX
ECurveBlendOption* {.size: sizeof(uint8), pure.} = enum
Override, DoNotOverride, NormalizeByWeight, BlendByWeight, UseBasePose,
UseMaxValue, UseMinValue, ECurveBlendOption_MAX
EAnimInterpolationType* {.size: sizeof(uint8), pure.} = enum
Linear, Step, EAnimInterpolationType_MAX
EAxisOption* {.size: sizeof(uint8), pure.} = enum
X, Y, Z, X_Neg, Y_Neg, Z_Neg, Custom, EAxisOption_MAX
EComponentType* {.size: sizeof(uint8), pure.} = enum
None, TranslationX, TranslationY, TranslationZ, RotationX, RotationY,
RotationZ, Scale, ScaleX, ScaleY, ScaleZ, EComponentType_MAX
EAudioOutputTarget* {.size: sizeof(uint8), pure.} = enum
Speaker, Controller, ControllerFallbackToSpeaker, EAudioOutputTarget_MAX
EBlendableLocation* {.size: sizeof(uint8), pure.} = enum
BL_AfterTonemapping, BL_BeforeTonemapping, BL_BeforeTranslucency,
BL_ReplacingTonemapper, BL_SSRInput, BL_MAX
EBlendSpaceAxis* {.size: sizeof(uint8), pure.} = enum
BSA_None, BSA_X, BSA_Y, BSA_MAX
EPreferredTriangulationDirection* {.size: sizeof(uint8), pure.} = enum
None, Tangential, Radial, EPreferredTriangulationDirection_MAX
ENotifyTriggerMode* {.size: sizeof(uint8), pure.} = enum
AllAnimations, HighestWeightedAnimation, None, ENotifyTriggerMode_MAX
EBlueprintStatus* {.size: sizeof(uint8), pure.} = enum
BS_Unknown, BS_Dirty, BS_Error, BS_UpToDate, BS_BeingCreated,
BS_UpToDateWithWarnings, BS_MAX
EBlueprintType* {.size: sizeof(uint8), pure.} = enum
BPTYPE_Normal, BPTYPE_Const, BPTYPE_MacroLibrary, BPTYPE_Interface,
BPTYPE_LevelScript, BPTYPE_FunctionLibrary, BPTYPE_MAX
EBlueprintCompileMode* {.size: sizeof(uint8), pure.} = enum
Default, Development, FinalRelease, EBlueprintCompileMode_MAX
EBlueprintNativizationFlag* {.size: sizeof(uint8), pure.} = enum
Disabled, Dependency, ExplicitlyEnabled, EBlueprintNativizationFlag_MAX
EShouldCookBlueprintPropertyGuids* {.size: sizeof(uint8), pure.} = enum
No, Yes, Inherit, EShouldCookBlueprintPropertyGuids_MAX
ECsgOper* {.size: sizeof(uint8), pure.} = enum
CSG_Active, CSG_Add, CSG_Subtract, CSG_Intersect, CSG_Deintersect, CSG_None,
CSG_MAX
EBrushType* {.size: sizeof(uint8), pure.} = enum
Brush_Default, Brush_Add, Brush_Subtract, Brush_MAX
ECameraProjectionMode* {.size: sizeof(uint8), pure.} = enum
Perspective, Orthographic, ECameraProjectionMode_MAX
ECameraShakePlaySpace* {.size: sizeof(uint8), pure.} = enum
CameraLocal, World, UserDefined, ECameraShakePlaySpace_MAX
ECloudStorageDelegate* {.size: sizeof(uint8), pure.} = enum
CSD_KeyValueReadComplete, CSD_KeyValueWriteComplete, CSD_ValueChanged,
CSD_DocumentQueryComplete, CSD_DocumentReadComplete,
CSD_DocumentWriteComplete, CSD_DocumentConflictDetected, CSD_MAX
EContentBundleClientState* {.size: sizeof(uint8), pure.} = enum
Unregistered, Registered, ContentInjectionRequested,
ContentRemovalRequested, RegistrationFailed, EContentBundleClientState_MAX
EWorldContentState* {.size: sizeof(uint8), pure.} = enum
NoContent, ContentBundleInjected, ContentBundleInjectionFailed,
EWorldContentState_MAX
EContentBundleStatus* {.size: sizeof(uint8), pure.} = enum
Registered, ReadyToInject, FailedToInject, ContentInjected, Unknown,
EContentBundleStatus_MAX
ECustomAttributeBlendType* {.size: sizeof(uint8), pure.} = enum
Override, Blend, ECustomAttributeBlendType_MAX
EDataLayerType* {.size: sizeof(uint8), pure.} = enum
Runtime, Editor, Unknown, Size, EDataLayerType_MAX
DistributionParamMode* {.size: sizeof(uint8), pure.} = enum
DPM_Normal, DPM_Abs, DPM_Direct, DPM_MAX
EDistributionVectorLockFlags* {.size: sizeof(uint8), pure.} = enum
EDVLF_None, EDVLF_XY, EDVLF_XZ, EDVLF_YZ, EDVLF_XYZ, EDVLF_MAX
EDistributionVectorMirrorFlags* {.size: sizeof(uint8), pure.} = enum
EDVMF_Same, EDVMF_Different, EDVMF_Mirror, EDVMF_MAX
EEdGraphPinDirection* {.size: sizeof(uint8), pure.} = enum
EGPD_Input, EGPD_Output, EGPD_MAX
EPinContainerType* {.size: sizeof(uint8), pure.} = enum
None, Array, Set, Map, EPinContainerType_MAX
ENodeTitleType* {.size: sizeof(uint8), pure.} = enum
FullTitle, ListView, EditableTitle, MenuTitle, MAX_TitleTypes,
ENodeTitleType_MAX
ENodeAdvancedPins* {.size: sizeof(uint8), pure.} = enum
NoPins, Shown, Hidden, ENodeAdvancedPins_MAX
ENodeEnabledState* {.size: sizeof(uint8), pure.} = enum
Enabled, Disabled, DevelopmentOnly, ENodeEnabledState_MAX
EBlueprintPinStyleType* {.size: sizeof(uint8), pure.} = enum
BPST_Original, BPST_VariantA, BPST_MAX
EGraphType* {.size: sizeof(uint8), pure.} = enum
GT_Function, GT_Ubergraph, GT_Macro, GT_Animation, GT_StateMachine, GT_MAX
ECanCreateConnectionResponse* {.size: sizeof(uint8), pure.} = enum
CONNECT_RESPONSE_MAKE, CONNECT_RESPONSE_DISALLOW,
CONNECT_RESPONSE_BREAK_OTHERS_A, CONNECT_RESPONSE_BREAK_OTHERS_B,
CONNECT_RESPONSE_BREAK_OTHERS_AB,
CONNECT_RESPONSE_MAKE_WITH_CONVERSION_NODE,
CONNECT_RESPONSE_MAKE_WITH_PROMOTION, CONNECT_RESPONSE_MAX
EFullyLoadPackageType* {.size: sizeof(uint8), pure.} = enum
FULLYLOAD_Map, FULLYLOAD_Game_PreLoadClass, FULLYLOAD_Game_PostLoadClass,
FULLYLOAD_Always, FULLYLOAD_Mutator, FULLYLOAD_MAX
ETransitionType* {.size: sizeof(uint8), pure.} = enum
None, Paused, Loading, Saving, Connecting, Precaching, WaitingToConnect, MAX
EMouseCaptureMode* {.size: sizeof(uint8), pure.} = enum
NoCapture, CapturePermanently, CapturePermanently_IncludingInitialMouseDown,
CaptureDuringMouseDown, CaptureDuringRightMouseDown, EMouseCaptureMode_MAX
ENetworkLagState* {.size: sizeof(uint8), pure.} = enum
NotLagging, Lagging, ENetworkLagState_MAX
ETravelType* {.size: sizeof(uint8), pure.} = enum
TRAVEL_Absolute, TRAVEL_Partial, TRAVEL_Relative, TRAVEL_MAX
EDemoPlayFailure* {.size: sizeof(uint8), pure.} = enum
Generic, DemoNotFound, Corrupt, InvalidVersion, InitBase,
GameSpecificHeader, ReplayStreamerInternal, LoadMap, Serialization,
EDemoPlayFailure_MAX
EViewModeIndex* {.size: sizeof(uint8), pure.} = enum
VMI_BrushWireframe, VMI_Wireframe, VMI_Unlit, VMI_Lit,
VMI_Lit_DetailLighting, VMI_LightingOnly, VMI_LightComplexity,
VMI_ShaderComplexity, VMI_LightmapDensity, VMI_LitLightmapDensity,
VMI_ReflectionOverride, VMI_VisualizeBuffer, VMI_StationaryLightOverlap,
VMI_CollisionPawn, VMI_CollisionVisibility, VMI_LODColoration,
VMI_QuadOverdraw, VMI_PrimitiveDistanceAccuracy, VMI_MeshUVDensityAccuracy,
VMI_ShaderComplexityWithQuadOverdraw, VMI_HLODColoration,
VMI_GroupLODColoration, VMI_MaterialTextureScaleAccuracy,
VMI_RequiredTextureResolution, VMI_PathTracing, VMI_RayTracingDebug,
VMI_VisualizeNanite, VMI_VirtualTexturePendingMips, VMI_VisualizeLumen,
VMI_VisualizeVirtualShadowMap, VMI_VisualizeGPUSkinCache, VMI_Max,
VMI_Unknown
EAspectRatioAxisConstraint* {.size: sizeof(uint8), pure.} = enum
AspectRatio_MaintainYFOV, AspectRatio_MaintainXFOV,
AspectRatio_MajorAxisFOV, AspectRatio_MAX
ESceneDepthPriorityGroup* {.size: sizeof(uint8), pure.} = enum
SDPG_World, SDPG_Foreground, SDPG_MAX
EIndirectLightingCacheQuality* {.size: sizeof(uint8), pure.} = enum
ILCQ_Off, ILCQ_Point, ILCQ_Volume, ILCQ_MAX
ELightmapType* {.size: sizeof(uint8), pure.} = enum
Default, ForceSurface, ForceVolumetric, ELightmapType_MAX
EOcclusionCombineMode* {.size: sizeof(uint8), pure.} = enum
OCM_Minimum, OCM_Multiply, OCM_MAX
EBlendMode* {.size: sizeof(uint8), pure.} = enum
BLEND_Opaque, BLEND_Masked, BLEND_Translucent, BLEND_Additive,
BLEND_Modulate, BLEND_AlphaComposite, BLEND_AlphaHoldout, BLEND_MAX
EStrataBlendMode* {.size: sizeof(uint8), pure.} = enum
SBM_Opaque, SBM_Masked, SBM_TranslucentGreyTransmittance,
SBM_TranslucentColoredTransmittance, SBM_ColoredTransmittanceOnly,
SBM_AlphaHoldout, SBM_MAX
EMaterialFloatPrecisionMode* {.size: sizeof(uint8), pure.} = enum
MFPM_Default, MFPM_Full_MaterialExpressionOnly, MFPM_Full, MFPM_Half,
MFPM_MAX
ESamplerSourceMode* {.size: sizeof(uint8), pure.} = enum
SSM_FromTextureAsset, SSM_Wrap_WorldGroupSettings,
SSM_Clamp_WorldGroupSettings, SSM_TerrainWeightmapGroupSettings, SSM_MAX
ETextureMipValueMode* {.size: sizeof(uint8), pure.} = enum
TMVM_None, TMVM_MipLevel, TMVM_MipBias, TMVM_Derivative, TMVM_MAX
ETranslucencyLightingMode* {.size: sizeof(uint8), pure.} = enum
TLM_VolumetricNonDirectional, TLM_VolumetricDirectional,
TLM_VolumetricPerVertexNonDirectional, TLM_VolumetricPerVertexDirectional,
TLM_Surface, TLM_SurfacePerPixelLighting, TLM_MAX
ERefractionMode* {.size: sizeof(uint8), pure.} = enum
RM_IndexOfRefraction, RM_PixelNormalOffset, RM_MAX
ETranslucentSortPolicy* {.size: sizeof(uint8), pure.} = enum
SortByDistance, SortByProjectedZ, SortAlongAxis, ETranslucentSortPolicy_MAX
EDynamicGlobalIlluminationMethod* {.size: sizeof(uint8), pure.} = enum
None, Lumen, ScreenSpace, RayTraced, Plugin,
EDynamicGlobalIlluminationMethod_MAX
EReflectionMethod* {.size: sizeof(uint8), pure.} = enum
None, Lumen, ScreenSpace, RayTraced, EReflectionMethod_MAX
EShadowMapMethod* {.size: sizeof(uint8), pure.} = enum
ShadowMaps, VirtualShadowMaps, EShadowMapMethod_MAX
ECastRayTracedShadow* {.size: sizeof(uint8), pure.} = enum
Disabled, UseProjectSetting, Enabled, ECastRayTracedShadow_MAX
ESceneCaptureSource* {.size: sizeof(uint8), pure.} = enum
SCS_SceneColorHDR, SCS_SceneColorHDRNoAlpha, SCS_FinalColorLDR,
SCS_SceneColorSceneDepth, SCS_SceneDepth, SCS_DeviceDepth, SCS_Normal,
SCS_BaseColor, SCS_FinalColorHDR, SCS_FinalToneCurveHDR, SCS_MAX
ESceneCaptureCompositeMode* {.size: sizeof(uint8), pure.} = enum
SCCM_Overwrite, SCCM_Additive, SCCM_Composite, SCCM_MAX
EGBufferFormat* {.size: sizeof(uint8), pure.} = enum
Force8BitsPerChannel, Default, HighPrecisionNormals, Force16BitsPerChannel,
EGBufferFormat_MAX
ETrailWidthMode* {.size: sizeof(uint8), pure.} = enum
ETrailWidthMode_FromCentre, ETrailWidthMode_FromFirst,
ETrailWidthMode_FromSecond, ETrailWidthMode_MAX
EParticleCollisionMode* {.size: sizeof(uint8), pure.} = enum
SceneDepth, DistanceField, EParticleCollisionMode_MAX
EMaterialShadingModel* {.size: sizeof(uint8), pure.} = enum
MSM_Unlit, MSM_DefaultLit, MSM_Subsurface, MSM_PreintegratedSkin,
MSM_ClearCoat, MSM_SubsurfaceProfile, MSM_TwoSidedFoliage, MSM_Hair,
MSM_Cloth, MSM_Eye, MSM_SingleLayerWater, MSM_ThinTranslucent, MSM_Strata,
MSM_NUM, MSM_FromMaterialExpression, MSM_MAX
EStrataShadingModel* {.size: sizeof(uint8), pure.} = enum
SSM_Unlit, SSM_DefaultLit, SSM_SubsurfaceLit, SSM_VolumetricFogCloud,
SSM_Hair, SSM_Eye, SSM_SingleLayerWater, SSM_LightFunction, SSM_PostProcess,
SSM_Decal, SSM_NUM
EMaterialSamplerType* {.size: sizeof(uint8), pure.} = enum
SAMPLERTYPE_Color, SAMPLERTYPE_Grayscale, SAMPLERTYPE_Alpha,
SAMPLERTYPE_Normal, SAMPLERTYPE_Masks, SAMPLERTYPE_DistanceFieldFont,
SAMPLERTYPE_LinearColor, SAMPLERTYPE_LinearGrayscale, SAMPLERTYPE_Data,
SAMPLERTYPE_External, SAMPLERTYPE_VirtualColor,
SAMPLERTYPE_VirtualGrayscale, SAMPLERTYPE_VirtualAlpha,
SAMPLERTYPE_VirtualNormal, SAMPLERTYPE_VirtualMasks,
SAMPLERTYPE_VirtualLinearColor, SAMPLERTYPE_VirtualLinearGrayscale,
SAMPLERTYPE_MAX
EMaterialStencilCompare* {.size: sizeof(uint8), pure.} = enum
MSC_Less, MSC_LessEqual, MSC_Greater, MSC_GreaterEqual, MSC_Equal,
MSC_NotEqual, MSC_Never, MSC_Always, MSC_Count, MSC_MAX
EMaterialShadingRate* {.size: sizeof(uint8), pure.} = enum
MSR_1x1, MSR_2x1, MSR_1x2, MSR_2x2, MSR_4x2, MSR_2x4, MSR_4x4, MSR_Count,
MSR_MAX
ELightingBuildQuality* {.size: sizeof(uint8), pure.} = enum
Quality_Preview, Quality_Medium, Quality_High, Quality_Production,
Quality_MAX
ENetworkSmoothingMode* {.size: sizeof(uint8), pure.} = enum
Disabled, Linear, Exponential, ENetworkSmoothingMode_MAX
EOverlapFilterOption* {.size: sizeof(uint8), pure.} = enum
OverlapFilter_All, OverlapFilter_DynamicOnly, OverlapFilter_StaticOnly,
OverlapFilter_MAX
ECollisionResponse* {.size: sizeof(uint8), pure.} = enum
ECR_Ignore, ECR_Overlap, ECR_Block, ECR_MAX
EFilterInterpolationType* {.size: sizeof(uint8), pure.} = enum
BSIT_Average, BSIT_Linear, BSIT_Cubic, BSIT_EaseInOut,
BSIT_ExponentialDecay, BSIT_SpringDamper, BSIT_MAX
ETimelineSigType* {.size: sizeof(uint8), pure.} = enum
ETS_EventSignature, ETS_FloatSignature, ETS_VectorSignature,
ETS_LinearColorSignature, ETS_InvalidSignature, ETS_MAX
ECollisionEnabled* {.size: sizeof(uint8), pure.} = enum
NoCollision, QueryOnly, PhysicsOnly, QueryAndPhysics, ProbeOnly,
QueryAndProbe, ECollisionEnabled_MAX
ELightMapPaddingType* {.size: sizeof(uint8), pure.} = enum
LMPT_NormalPadding, LMPT_PrePadding, LMPT_NoPadding, LMPT_MAX
EShadowMapFlags* {.size: sizeof(uint8), pure.} = enum
SMF_None, SMF_Streamed, SMF_MAX
EUpdateRateShiftBucket* {.size: sizeof(uint8), pure.} = enum
ShiftBucket0, ShiftBucket1, ShiftBucket2, ShiftBucket3, ShiftBucket4,
ShiftBucket5, ShiftBucketMax, EUpdateRateShiftBucket_MAX
ENetRole* {.size: sizeof(uint8), pure.} = enum
ROLE_None, ROLE_SimulatedProxy, ROLE_AutonomousProxy, ROLE_Authority,
ROLE_MAX
ENetDormancy* {.size: sizeof(uint8), pure.} = enum
DORM_Never, DORM_Awake, DORM_DormantAll, DORM_DormantPartial, DORM_Initial,
DORM_MAX
EAutoReceiveInput* {.size: sizeof(uint8), pure.} = enum
Disabled, Player0, Player1, Player2, Player3, Player4, Player5, Player6,
Player7, EAutoReceiveInput_MAX
EAutoPossessAI* {.size: sizeof(uint8), pure.} = enum
Disabled, PlacedInWorld, Spawned, PlacedInWorldOrSpawned, EAutoPossessAI_MAX
EWalkableSlopeBehavior* {.size: sizeof(uint8), pure.} = enum
WalkableSlope_Default, WalkableSlope_Increase, WalkableSlope_Decrease,
WalkableSlope_Unwalkable, WalkableSlope_Max
EPhysicalMaterialMaskColor* {.size: sizeof(uint8), pure.} = enum
Red, Green, Blue, Cyan, Magenta, Yellow, White, Black, MAX
EComponentSocketType* {.size: sizeof(uint8), pure.} = enum
Invalid, Bone, Socket, EComponentSocketType_MAX
ESpawnActorCollisionHandlingMethod* {.size: sizeof(uint8), pure.} = enum
Undefined, AlwaysSpawn, AdjustIfPossibleButAlwaysSpawn,
AdjustIfPossibleButDontSpawnIfColliding, DontSpawnIfColliding,
ESpawnActorCollisionHandlingMethod_MAX
EMeshBufferAccess* {.size: sizeof(uint8), pure.} = enum
Default, ForceCPUAndGPU, EMeshBufferAccess_MAX
EFontImportCharacterSet* {.size: sizeof(uint8), pure.} = enum
FontICS_Default, FontICS_Ansi, FontICS_Symbol, FontICS_MAX
EStandbyType* {.size: sizeof(uint8), pure.} = enum
STDBY_Rx, STDBY_Tx, STDBY_BadPing, STDBY_MAX
ESuggestProjVelocityTraceOption* {.size: sizeof(uint8), pure.} = enum
DoNotTrace, TraceFullPath, OnlyTraceWhileAscending,
ESuggestProjVelocityTraceOption_MAX
EHISMViewRelevanceType* {.size: sizeof(uint8), pure.} = enum
Grass, Foliage, HISM, EHISMViewRelevanceType_MAX
EHitProxyPriority* {.size: sizeof(uint8), pure.} = enum
HPP_World, HPP_Wireframe, HPP_Foreground, HPP_UI, HPP_MAX
EHLODBatchingPolicy* {.size: sizeof(uint8), pure.} = enum
None, MeshSection, Instancing, EHLODBatchingPolicy_MAX
EAdManagerDelegate* {.size: sizeof(uint8), pure.} = enum
AMD_ClickedBanner, AMD_UserClosedAd, AMD_MAX
ERoundingMode* {.size: sizeof(uint8), pure.} = enum
HalfToEven, HalfFromZero, HalfToZero, FromZero, ToZero, ToNegativeInfinity,
ToPositiveInfinity, ERoundingMode_MAX
EScreenPercentageMode* {.size: sizeof(uint8), pure.} = enum
Manual, BasedOnDisplayResolution, BasedOnDPIScale, EScreenPercentageMode_MAX
ELevelInstanceRuntimeBehavior* {.size: sizeof(uint8), pure.} = enum
None, Embedded_Deprecated, Partitioned, LevelStreaming,
ELevelInstanceRuntimeBehavior_MAX
ELevelInstanceCreationType* {.size: sizeof(uint8), pure.} = enum
LevelInstance, PackedLevelActor, ELevelInstanceCreationType_MAX
ELevelInstancePivotType* {.size: sizeof(uint8), pure.} = enum
CenterMinZ, Center, Actor, WorldOrigin, ELevelInstancePivotType_MAX
EStreamingVolumeUsage* {.size: sizeof(uint8), pure.} = enum
SVB_Loading, SVB_LoadingAndVisibility, SVB_VisibilityBlockingOnLoad,
SVB_BlockingOnLoad, SVB_LoadingNotVisible, SVB_MAX
EDecalBlendMode* {.size: sizeof(uint8), pure.} = enum
DBM_Translucent, DBM_Stain, DBM_Normal, DBM_Emissive,
DBM_DBuffer_ColorNormalRoughness, DBM_DBuffer_Color,
DBM_DBuffer_ColorNormal, DBM_DBuffer_ColorRoughness, DBM_DBuffer_Normal,
DBM_DBuffer_NormalRoughness, DBM_DBuffer_Roughness, DBM_DBuffer_Emissive,
DBM_DBuffer_AlphaComposite, DBM_DBuffer_EmissiveAlphaComposite,
DBM_Volumetric_DistanceFunction, DBM_AlphaComposite, DBM_AmbientOcclusion,
DBM_MAX
EMaterialDecalResponse* {.size: sizeof(uint8), pure.} = enum
MDR_None, MDR_ColorNormalRoughness, MDR_Color, MDR_ColorNormal,
MDR_ColorRoughness, MDR_Normal, MDR_NormalRoughness, MDR_Roughness, MDR_MAX
EMaterialTranslucencyPass* {.size: sizeof(uint8), pure.} = enum
MTP_BeforeDOF, MTP_AfterDOF, MTP_AfterMotionBlur, MTP_MAX
ETextureColorChannel* {.size: sizeof(uint8), pure.} = enum
TCC_Red, TCC_Green, TCC_Blue, TCC_Alpha, TCC_MAX
EMaterialAttributeBlend* {.size: sizeof(uint8), pure.} = enum
Blend, UseA, UseB, EMaterialAttributeBlend_MAX
EChannelMaskParameterColor* {.size: sizeof(uint8), pure.} = enum
Red, Green, Blue, Alpha, EChannelMaskParameterColor_MAX
EClampMode* {.size: sizeof(uint8), pure.} = enum
CMODE_Clamp, CMODE_ClampMin, CMODE_ClampMax, CMODE_MAX
ECustomMaterialOutputType* {.size: sizeof(uint8), pure.} = enum
CMOT_Float1, CMOT_Float2, CMOT_Float3, CMOT_Float4, CMOT_MaterialAttributes,
CMOT_MAX
EDBufferTextureId* {.size: sizeof(uint8), pure.} = enum
DBT_A, DBT_B, DBT_C, DBT_MAX
EDepthOfFieldFunctionValue* {.size: sizeof(uint8), pure.} = enum
TDOF_NearAndFarMask, TDOF_NearMask, TDOF_FarMask,
TDOF_CircleOfConfusionRadius, TDOF_MAX
EFunctionInputType* {.size: sizeof(uint8), pure.} = enum
FunctionInput_Scalar, FunctionInput_Vector2, FunctionInput_Vector3,
FunctionInput_Vector4, FunctionInput_Texture2D, FunctionInput_TextureCube,
FunctionInput_Texture2DArray, FunctionInput_VolumeTexture,
FunctionInput_StaticBool, FunctionInput_MaterialAttributes,
FunctionInput_TextureExternal, FunctionInput_MAX
ENoiseFunction* {.size: sizeof(uint8), pure.} = enum
NOISEFUNCTION_SimplexTex, NOISEFUNCTION_GradientTex,
NOISEFUNCTION_GradientTex3D, NOISEFUNCTION_GradientALU,
NOISEFUNCTION_ValueALU, NOISEFUNCTION_VoronoiALU, NOISEFUNCTION_MAX
ERuntimeVirtualTextureMipValueMode* {.size: sizeof(uint8), pure.} = enum
RVTMVM_None, RVTMVM_MipLevel, RVTMVM_MipBias, RVTMVM_RecalculateDerivatives,
RVTMVM_MAX
ERuntimeVirtualTextureTextureAddressMode* {.size: sizeof(uint8), pure.} = enum
RVTTA_Clamp, RVTTA_Wrap, RVTTA_MAX
EMaterialSceneAttributeInputMode* {.size: sizeof(uint8), pure.} = enum
Coordinates, OffsetFraction, EMaterialSceneAttributeInputMode_MAX
ESpeedTreeGeometryType* {.size: sizeof(uint8), pure.} = enum
STG_Branch, STG_Frond, STG_Leaf, STG_FacingLeaf, STG_Billboard, STG_MAX
ESpeedTreeWindType* {.size: sizeof(uint8), pure.} = enum
STW_None, STW_Fastest, STW_Fast, STW_Better, STW_Best, STW_Palm,
STW_BestPlus, STW_MAX
ESpeedTreeLODType* {.size: sizeof(uint8), pure.} = enum
STLOD_Pop, STLOD_Smooth, STLOD_MAX
EMaterialExposedTextureProperty* {.size: sizeof(uint8), pure.} = enum
TMTM_TextureSize, TMTM_TexelSize, TMTM_MAX
EMaterialVectorCoordTransformSource* {.size: sizeof(uint8), pure.} = enum
TRANSFORMSOURCE_Tangent, TRANSFORMSOURCE_Local, TRANSFORMSOURCE_World,
TRANSFORMSOURCE_View, TRANSFORMSOURCE_Camera, TRANSFORMSOURCE_ParticleWorld,
TRANSFORMSOURCE_Instance, TRANSFORMSOURCE_MAX
EMaterialVectorCoordTransform* {.size: sizeof(uint8), pure.} = enum
TRANSFORM_Tangent, TRANSFORM_Local, TRANSFORM_World, TRANSFORM_View,
TRANSFORM_Camera, TRANSFORM_ParticleWorld, TRANSFORM_Instance, TRANSFORM_MAX
EMaterialPositionTransformSource* {.size: sizeof(uint8), pure.} = enum
TRANSFORMPOSSOURCE_Local, TRANSFORMPOSSOURCE_World,
TRANSFORMPOSSOURCE_TranslatedWorld, TRANSFORMPOSSOURCE_View,
TRANSFORMPOSSOURCE_Camera, TRANSFORMPOSSOURCE_Particle,
TRANSFORMPOSSOURCE_Instance, TRANSFORMPOSSOURCE_MAX
EVectorNoiseFunction* {.size: sizeof(uint8), pure.} = enum
VNF_CellnoiseALU, VNF_VectorALU, VNF_GradientALU, VNF_CurlALU,
VNF_VoronoiALU, VNF_MAX
EMaterialExposedViewProperty* {.size: sizeof(uint8), pure.} = enum
MEVP_BufferSize, MEVP_FieldOfView, MEVP_TanHalfFieldOfView, MEVP_ViewSize,
MEVP_WorldSpaceViewPosition, MEVP_WorldSpaceCameraPosition,
MEVP_ViewportOffset, MEVP_TemporalSampleCount, MEVP_TemporalSampleIndex,
MEVP_TemporalSampleOffset, MEVP_RuntimeVirtualTextureOutputLevel,
MEVP_RuntimeVirtualTextureOutputDerivative, MEVP_PreExposure,
MEVP_RuntimeVirtualTextureMaxLevel, MEVP_ResolutionFraction, MEVP_MAX
EWorldPositionIncludedOffsets* {.size: sizeof(uint8), pure.} = enum
WPT_Default, WPT_ExcludeAllShaderOffsets, WPT_CameraRelative,
WPT_CameraRelativeNoOffsets, WPT_MAX
EMaterialFunctionUsage* {.size: sizeof(uint8), pure.} = enum
Default, MaterialLayer, MaterialLayerBlend, EMaterialFunctionUsage_MAX
EMaterialUsage* {.size: sizeof(uint8), pure.} = enum
MATUSAGE_SkeletalMesh, MATUSAGE_ParticleSprites, MATUSAGE_BeamTrails,
MATUSAGE_MeshParticles, MATUSAGE_StaticLighting, MATUSAGE_MorphTargets,
MATUSAGE_SplineMesh, MATUSAGE_InstancedStaticMeshes,
MATUSAGE_GeometryCollections, MATUSAGE_Clothing, MATUSAGE_NiagaraSprites,
MATUSAGE_NiagaraRibbons, MATUSAGE_NiagaraMeshParticles,
MATUSAGE_GeometryCache, MATUSAGE_Water, MATUSAGE_HairStrands,
MATUSAGE_LidarPointCloud, MATUSAGE_VirtualHeightfieldMesh, MATUSAGE_Nanite,
MATUSAGE_MAX
EMaterialLayerLinkState* {.size: sizeof(uint8), pure.} = enum
Uninitialized, LinkedToParent, UnlinkedFromParent, NotFromParent,
EMaterialLayerLinkState_MAX
ETextureSizingType* {.size: sizeof(uint8), pure.} = enum
TextureSizingType_UseSingleTextureSize,
TextureSizingType_UseAutomaticBiasedSizes,
TextureSizingType_UseManualOverrideTextureSize,
TextureSizingType_UseSimplygonAutomaticSizing,
TextureSizingType_AutomaticFromTexelDensity,
TextureSizingType_AutomaticFromMeshScreenSize,
TextureSizingType_AutomaticFromMeshDrawDistance, TextureSizingType_MAX
EMaterialMergeType* {.size: sizeof(uint8), pure.} = enum
MaterialMergeType_Default, MaterialMergeType_Simplygon,
MaterialMergeType_MAX
ESceneTextureId* {.size: sizeof(uint8), pure.} = enum
PPI_SceneColor, PPI_SceneDepth, PPI_DiffuseColor, PPI_SpecularColor,
PPI_SubsurfaceColor, PPI_BaseColor, PPI_Specular, PPI_Metallic,
PPI_WorldNormal, PPI_SeparateTranslucency, PPI_Opacity, PPI_Roughness,
PPI_MaterialAO, PPI_CustomDepth, PPI_PostProcessInput0,
PPI_PostProcessInput1, PPI_PostProcessInput2, PPI_PostProcessInput3,
PPI_PostProcessInput4, PPI_PostProcessInput5, PPI_PostProcessInput6,
PPI_DecalMask, PPI_ShadingModelColor, PPI_ShadingModelID,
PPI_AmbientOcclusion, PPI_CustomStencil, PPI_StoredBaseColor,
PPI_StoredSpecular, PPI_Velocity, PPI_WorldTangent, PPI_Anisotropy, PPI_MAX
EMaterialDomain* {.size: sizeof(uint8), pure.} = enum
MD_Surface, MD_DeferredDecal, MD_LightFunction, MD_Volume, MD_PostProcess,
MD_UI, MD_RuntimeVirtualTexture, MD_MAX
EMaterialParameterAssociation* {.size: sizeof(uint8), pure.} = enum
LayerParameter, BlendParameter, GlobalParameter,
EMaterialParameterAssociation_MAX
EMicroTransactionDelegate* {.size: sizeof(uint8), pure.} = enum
MTD_PurchaseQueryComplete, MTD_PurchaseComplete, MTD_MAX
EMicroTransactionResult* {.size: sizeof(uint8), pure.} = enum
MTR_Succeeded, MTR_Failed, MTR_Canceled, MTR_RestoredFromServer, MTR_MAX
ENavLinkDirection* {.size: sizeof(uint8), pure.} = enum
BothWays, LeftToRight, RightToLeft, ENavLinkDirection_MAX
EPingType* {.size: sizeof(uint8), pure.} = enum
None, RoundTrip, RoundTripExclFrame, ICMP, UDPQoS, Max, Count, EPingType_MAX
EPingAverageType* {.size: sizeof(uint8), pure.} = enum
None, MovingAverage, PlayerStateAvg, EPingAverageType_MAX
EParticleBurstMethod* {.size: sizeof(uint8), pure.} = enum
EPBM_Instant, EPBM_Interpolated, EPBM_MAX
EParticleSubUVInterpMethod* {.size: sizeof(uint8), pure.} = enum
PSUVIM_None, PSUVIM_Linear, PSUVIM_Linear_Blend, PSUVIM_Random,
PSUVIM_Random_Blend, PSUVIM_MAX
EEmitterRenderMode* {.size: sizeof(uint8), pure.} = enum
ERM_Normal, ERM_Point, ERM_Cross, ERM_LightsOnly, ERM_None, ERM_MAX
EParticleDetailMode* {.size: sizeof(uint8), pure.} = enum
PDM_Low, PDM_Medium, PDM_High, PDM_MAX
EParticleSignificanceLevel* {.size: sizeof(uint8), pure.} = enum
Low, Medium, High, Critical, Num, EParticleSignificanceLevel_MAX
EParticleSystemInsignificanceReaction* {.size: sizeof(uint8), pure.} = enum
Auto, Complete, DisableTick, DisableTickAndKill, Num,
EParticleSystemInsignificanceReaction_MAX
EModuleType* {.size: sizeof(uint8), pure.} = enum
EPMT_General, EPMT_TypeData, EPMT_Beam, EPMT_Trail, EPMT_Spawn,
EPMT_Required, EPMT_Event, EPMT_Light, EPMT_SubUV, EPMT_MAX
EParticleSourceSelectionMethod* {.size: sizeof(uint8), pure.} = enum
EPSSM_Random, EPSSM_Sequential, EPSSM_MAX
EAttractorParticleSelectionMethod* {.size: sizeof(uint8), pure.} = enum
EAPSM_Random, EAPSM_Sequential, EAPSM_MAX
Beam2SourceTargetMethod* {.size: sizeof(uint8), pure.} = enum
PEB2STM_Default, PEB2STM_UserSet, PEB2STM_Emitter, PEB2STM_Particle,
PEB2STM_Actor, PEB2STM_MAX
Beam2SourceTargetTangentMethod* {.size: sizeof(uint8), pure.} = enum
PEB2STTM_Direct, PEB2STTM_UserSet, PEB2STTM_Distribution, PEB2STTM_Emitter,
PEB2STTM_MAX
BeamModifierType* {.size: sizeof(uint8), pure.} = enum
PEB2MT_Source, PEB2MT_Target, PEB2MT_MAX
EParticleCameraOffsetUpdateMethod* {.size: sizeof(uint8), pure.} = enum
EPCOUM_DirectSet, EPCOUM_Additive, EPCOUM_Scalar, EPCOUM_MAX
EParticleCollisionComplete* {.size: sizeof(uint8), pure.} = enum
EPCC_Kill, EPCC_Freeze, EPCC_HaltCollisions, EPCC_FreezeTranslation,
EPCC_FreezeRotation, EPCC_FreezeMovement, EPCC_MAX
EParticleCollisionResponse* {.size: sizeof(uint8), pure.} = enum
Bounce, Stop, Kill, EParticleCollisionResponse_MAX
ELocationBoneSocketSource* {.size: sizeof(uint8), pure.} = enum
BONESOCKETSOURCE_Bones, BONESOCKETSOURCE_Sockets, BONESOCKETSOURCE_MAX
ELocationBoneSocketSelectionMethod* {.size: sizeof(uint8), pure.} = enum
BONESOCKETSEL_Sequential, BONESOCKETSEL_Random, BONESOCKETSEL_MAX
ELocationEmitterSelectionMethod* {.size: sizeof(uint8), pure.} = enum
ELESM_Random, ELESM_Sequential, ELESM_MAX
CylinderHeightAxis* {.size: sizeof(uint8), pure.} = enum
PMLPC_HEIGHTAXIS_X, PMLPC_HEIGHTAXIS_Y, PMLPC_HEIGHTAXIS_Z,
PMLPC_HEIGHTAXIS_MAX
ELocationSkelVertSurfaceSource* {.size: sizeof(uint8), pure.} = enum
VERTSURFACESOURCE_Vert, VERTSURFACESOURCE_Surface, VERTSURFACESOURCE_MAX
EOrbitChainMode* {.size: sizeof(uint8), pure.} = enum
EOChainMode_Add, EOChainMode_Scale, EOChainMode_Link, EOChainMode_MAX
EParticleAxisLock* {.size: sizeof(uint8), pure.} = enum
EPAL_NONE, EPAL_X, EPAL_Y, EPAL_Z, EPAL_NEGATIVE_X, EPAL_NEGATIVE_Y,
EPAL_NEGATIVE_Z, EPAL_ROTATE_X, EPAL_ROTATE_Y, EPAL_ROTATE_Z, EPAL_MAX
EEmitterDynamicParameterValue* {.size: sizeof(uint8), pure.} = enum
EDPV_UserSet, EDPV_AutoSet, EDPV_VelocityX, EDPV_VelocityY, EDPV_VelocityZ,
EDPV_VelocityMag, EDPV_MAX
EParticleUVFlipMode* {.size: sizeof(uint8), pure.} = enum
None, FlipUV, FlipUOnly, FlipVOnly, RandomFlipUV, RandomFlipUOnly,
RandomFlipVOnly, RandomFlipUVIndependent, EParticleUVFlipMode_MAX
EParticleSortMode* {.size: sizeof(uint8), pure.} = enum
PSORTMODE_None, PSORTMODE_ViewProjDepth, PSORTMODE_DistanceToView,
PSORTMODE_Age_OldestFirst, PSORTMODE_Age_NewestFirst, PSORTMODE_MAX
EEmitterNormalsMode* {.size: sizeof(uint8), pure.} = enum
ENM_CameraFacing, ENM_Spherical, ENM_Cylindrical, ENM_MAX
ETrail2SourceMethod* {.size: sizeof(uint8), pure.} = enum
PET2SRCM_Default, PET2SRCM_Particle, PET2SRCM_Actor, PET2SRCM_MAX
EBeam2Method* {.size: sizeof(uint8), pure.} = enum
PEB2M_Distance, PEB2M_Target, PEB2M_Branch, PEB2M_MAX
EBeamTaperMethod* {.size: sizeof(uint8), pure.} = enum
PEBTM_None, PEBTM_Full, PEBTM_Partial, PEBTM_MAX
EMeshScreenAlignment* {.size: sizeof(uint8), pure.} = enum
PSMA_MeshFaceCameraWithRoll, PSMA_MeshFaceCameraWithSpin,
PSMA_MeshFaceCameraWithLockedAxis, PSMA_MAX
EMeshCameraFacingUpAxis* {.size: sizeof(uint8), pure.} = enum
CameraFacing_NoneUP, CameraFacing_ZUp, CameraFacing_NegativeZUp,
CameraFacing_YUp, CameraFacing_NegativeYUp, CameraFacing_MAX
EMeshCameraFacingOptions* {.size: sizeof(uint8), pure.} = enum
XAxisFacing_NoUp, XAxisFacing_ZUp, XAxisFacing_NegativeZUp, XAxisFacing_YUp,
XAxisFacing_NegativeYUp, LockedAxis_ZAxisFacing,
LockedAxis_NegativeZAxisFacing, LockedAxis_YAxisFacing,
LockedAxis_NegativeYAxisFacing, VelocityAligned_ZAxisFacing,
VelocityAligned_NegativeZAxisFacing, VelocityAligned_YAxisFacing,
VelocityAligned_NegativeYAxisFacing, EMeshCameraFacingOptions_MAX
ETrailsRenderAxisOption* {.size: sizeof(uint8), pure.} = enum
Trails_CameraUp, Trails_SourceUp, Trails_WorldUp, Trails_MAX
EParticleScreenAlignment* {.size: sizeof(uint8), pure.} = enum
PSA_FacingCameraPosition, PSA_Square, PSA_Rectangle, PSA_Velocity,
PSA_AwayFromCenter, PSA_TypeSpecific, PSA_FacingCameraDistanceBlend, PSA_MAX
EParticleSystemUpdateMode* {.size: sizeof(uint8), pure.} = enum
EPSUM_RealTime, EPSUM_FixedTime, EPSUM_MAX
ParticleSystemLODMethod* {.size: sizeof(uint8), pure.} = enum
PARTICLESYSTEMLODMETHOD_Automatic, PARTICLESYSTEMLODMETHOD_DirectSet,
PARTICLESYSTEMLODMETHOD_ActivateAutomatic, PARTICLESYSTEMLODMETHOD_MAX
EParticleSystemOcclusionBoundsMethod* {.size: sizeof(uint8), pure.} = enum
EPSOBM_None, EPSOBM_ParticleBounds, EPSOBM_CustomBounds, EPSOBM_MAX
EParticleSysParamType* {.size: sizeof(uint8), pure.} = enum
PSPT_None, PSPT_Scalar, PSPT_ScalarRand, PSPT_Vector, PSPT_VectorRand,
PSPT_Color, PSPT_Actor, PSPT_Material, PSPT_VectorUnitRand, PSPT_MAX
ParticleReplayState* {.size: sizeof(uint8), pure.} = enum
PRS_Disabled, PRS_Capturing, PRS_Replaying, PRS_MAX
EParticleEventType* {.size: sizeof(uint8), pure.} = enum
EPET_Any, EPET_Spawn, EPET_Death, EPET_Collision, EPET_Burst,
EPET_Blueprint, EPET_MAX
EViewTargetBlendFunction* {.size: sizeof(uint8), pure.} = enum
VTBlend_Linear, VTBlend_Cubic, VTBlend_EaseIn, VTBlend_EaseOut,
VTBlend_EaseInOut, VTBlend_PreBlended, VTBlend_MAX
ECanBeCharacterBase* {.size: sizeof(uint8), pure.} = enum
ECB_No, ECB_Yes, ECB_Owner, ECB_MAX
EHasCustomNavigableGeometry* {.size: sizeof(uint8), pure.} = enum
No, Yes, EvenIfNotCollidable, DontExport, EHasCustomNavigableGeometry_MAX
ERendererStencilMask* {.size: sizeof(uint8), pure.} = enum
ERSM_Default, ERSM_255, ERSM_1, ERSM_2, ERSM_4, ERSM_8, ERSM_16, ERSM_32,
ERSM_64, ERSM_128, ERSM_MAX
ERayTracingGroupCullingPriority* {.size: sizeof(uint8), pure.} = enum
CP_0_NEVER_CULL, CP_1, CP_2, CP_3, CP_4_DEFAULT, CP_5, CP_6, CP_7,
CP_8_QUICKLY_CULL, CP_MAX
ERichCurveInterpMode* {.size: sizeof(uint8), pure.} = enum
RCIM_Linear, RCIM_Constant, RCIM_Cubic, RCIM_None, RCIM_MAX
ERichCurveExtrapolation* {.size: sizeof(uint8), pure.} = enum
RCCE_Cycle, RCCE_CycleWithOffset, RCCE_Oscillate, RCCE_Linear,
RCCE_Constant, RCCE_None, RCCE_MAX
EReplayResult* {.size: sizeof(uint8), pure.} = enum
Success, ReplayNotFound, Corrupt, UnsupportedCheckpoint, GameSpecific,
InitConnect, LoadMap, Serialization, StreamerError, ConnectionClosed,
MissingArchive, Unknown, EReplayResult_MAX
ReverbPreset* {.size: sizeof(uint8), pure.} = enum
REVERB_Default, REVERB_Bathroom, REVERB_StoneRoom, REVERB_Auditorium,
REVERB_ConcertHall, REVERB_Cave, REVERB_Hallway, REVERB_StoneCorridor,
REVERB_Alley, REVERB_Forest, REVERB_City, REVERB_Mountains, REVERB_Quarry,
REVERB_Plain, REVERB_ParkingLot, REVERB_SewerPipe, REVERB_Underwater,
REVERB_SmallRoom, REVERB_MediumRoom, REVERB_LargeRoom, REVERB_MediumHall,
REVERB_LargeHall, REVERB_Plate, REVERB_MAX
ERichCurveTangentMode* {.size: sizeof(uint8), pure.} = enum
RCTM_Auto, RCTM_User, RCTM_Break, RCTM_None, RCTM_MAX
ERichCurveTangentWeightMode* {.size: sizeof(uint8), pure.} = enum
RCTWM_WeightedNone, RCTWM_WeightedArrive, RCTWM_WeightedLeave,
RCTWM_WeightedBoth, RCTWM_MAX
ERichCurveCompressionFormat* {.size: sizeof(uint8), pure.} = enum
RCCF_Empty, RCCF_Constant, RCCF_Linear, RCCF_Cubic, RCCF_Mixed,
RCCF_Weighted, RCCF_MAX
ERichCurveKeyTimeCompressionFormat* {.size: sizeof(uint8), pure.} = enum
RCKTCF_uint16, RCKTCF_float32, RCKTCF_MAX
ERuntimeVirtualTextureMaterialType* {.size: sizeof(uint8), pure.} = enum
BaseColor, BaseColor_Normal_DEPRECATED, BaseColor_Normal_Roughness,
BaseColor_Normal_Specular, BaseColor_Normal_Specular_YCoCg,
BaseColor_Normal_Specular_Mask_YCoCg, WorldHeight, Count,
ERuntimeVirtualTextureMaterialType_MAX
ERuntimeVirtualTextureMainPassType* {.size: sizeof(uint8), pure.} = enum
Never, Exclusive, Always, ERuntimeVirtualTextureMainPassType_MAX
EDepthOfFieldMethod* {.size: sizeof(uint8), pure.} = enum
DOFM_BokehDOF, DOFM_Gaussian, DOFM_CircleDOF, DOFM_MAX
EAutoExposureMethod* {.size: sizeof(uint8), pure.} = enum
AEM_Histogram, AEM_Basic, AEM_Manual, AEM_MAX
EBloomMethod* {.size: sizeof(uint8), pure.} = enum
BM_SOG, BM_FFT, BM_MAX
ETemperatureMethod* {.size: sizeof(uint8), pure.} = enum
TEMP_WhiteBalance, TEMP_ColorTemperature, TEMP_MAX
ELightUnits* {.size: sizeof(uint8), pure.} = enum
Unitless, Candelas, Lumens, ELightUnits_MAX
EReflectionsType* {.size: sizeof(uint8), pure.} = enum
ScreenSpace, RayTracing, EReflectionsType_MAX
ELumenRayLightingModeOverride* {.size: sizeof(uint8), pure.} = enum
Default, SurfaceCache, HitLighting, ELumenRayLightingModeOverride_MAX
ETranslucencyType* {.size: sizeof(uint8), pure.} = enum
Raster, RayTracing, ETranslucencyType_MAX
ERayTracingGlobalIlluminationType* {.size: sizeof(uint8), pure.} = enum
Disabled, BruteForce, FinalGather, ERayTracingGlobalIlluminationType_MAX
EReflectedAndRefractedRayTracedShadows* {.size: sizeof(uint8), pure.} = enum
Disabled, Hard_shadows, Area_shadows,
EReflectedAndRefractedRayTracedShadows_MAX
EMobilePlanarReflectionMode* {.size: sizeof(uint8), pure.} = enum
Usual, MobilePPRExclusive, MobilePPR, EMobilePlanarReflectionMode_MAX
EMobilePixelProjectedReflectionQuality* {.size: sizeof(uint8), pure.} = enum
Disabled, BestPerformance, BetterQuality, BestQuality,
EMobilePixelProjectedReflectionQuality_MAX
EMaterialProperty* {.size: sizeof(uint8), pure.} = enum
MP_EmissiveColor, MP_Opacity, MP_OpacityMask, MP_DiffuseColor,
MP_SpecularColor, MP_BaseColor, MP_Metallic, MP_Specular, MP_Roughness,
MP_Anisotropy, MP_Normal, MP_Tangent, MP_WorldPositionOffset,
MP_WorldDisplacement_DEPRECATED, MP_TessellationMultiplier_DEPRECATED,
MP_SubsurfaceColor, MP_CustomData0, MP_CustomData1, MP_AmbientOcclusion,
MP_Refraction, MP_CustomizedUVs0, MP_CustomizedUVs1, MP_CustomizedUVs2,
MP_CustomizedUVs3, MP_CustomizedUVs4, MP_CustomizedUVs5, MP_CustomizedUVs6,
MP_CustomizedUVs7, MP_PixelDepthOffset, MP_ShadingModel, MP_FrontMaterial,
MP_MaterialAttributes, MP_CustomOutput, MP_MAX
EAntiAliasingMethod* {.size: sizeof(uint8), pure.} = enum
AAM_None, AAM_FXAA, AAM_TemporalAA, AAM_MSAA, AAM_TSR, AAM_MAX
ESkeletalMeshGeoImportVersions* {.size: sizeof(uint8), pure.} = enum
Before_Versionning, SkeletalMeshBuildRefactor, VersionPlusOne,
LatestVersion, ESkeletalMeshGeoImportVersions_MAX
ESkeletalMeshSkinningImportVersions* {.size: sizeof(uint8), pure.} = enum
Before_Versionning, SkeletalMeshBuildRefactor, VersionPlusOne,
LatestVersion, ESkeletalMeshSkinningImportVersions_MAX
SkeletalMeshTerminationCriterion* {.size: sizeof(uint8), pure.} = enum
SMTC_NumOfTriangles, SMTC_NumOfVerts, SMTC_TriangleOrVert,
SMTC_AbsNumOfTriangles, SMTC_AbsNumOfVerts, SMTC_AbsTriangleOrVert, SMTC_MAX
SkeletalMeshOptimizationType* {.size: sizeof(uint8), pure.} = enum
SMOT_NumOfTriangles, SMOT_MaxDeviation, SMOT_TriangleOrDeviation, SMOT_MAX
SkeletalMeshOptimizationImportance* {.size: sizeof(uint8), pure.} = enum
SMOI_Off, SMOI_Lowest, SMOI_Low, SMOI_Normal, SMOI_High, SMOI_Highest,
SMOI_MAX
ESkinCacheUsage* {.size: sizeof(uint8), pure.} = enum
Auto, Disabled, Enabled, ESkinCacheUsage_MAX
ESkinCacheDefaultBehavior* {.size: sizeof(uint8), pure.} = enum
Exclusive, Inclusive, ESkinCacheDefaultBehavior_MAX
EBoneVisibilityStatus* {.size: sizeof(uint8), pure.} = enum
BVS_HiddenByParent, BVS_Visible, BVS_ExplicitlyHidden, BVS_MAX
EPhysBodyOp* {.size: sizeof(uint8), pure.} = enum
PBO_None, PBO_Term, PBO_MAX
EVisibilityBasedAnimTickOption* {.size: sizeof(uint8), pure.} = enum
AlwaysTickPoseAndRefreshBones, AlwaysTickPose,
OnlyTickMontagesWhenNotRendered, OnlyTickPoseWhenRendered,
EVisibilityBasedAnimTickOption_MAX
EBoneSpaces* {.size: sizeof(uint8), pure.} = enum
WorldSpace, ComponentSpace, EBoneSpaces_MAX
ESkyLightSourceType* {.size: sizeof(uint8), pure.} = enum
SLS_CapturedScene, SLS_SpecifiedCubemap, SLS_MAX
ESoundDistanceCalc* {.size: sizeof(uint8), pure.} = enum
SOUNDDISTANCE_Normal, SOUNDDISTANCE_InfiniteXYPlane,
SOUNDDISTANCE_InfiniteXZPlane, SOUNDDISTANCE_InfiniteYZPlane,
SOUNDDISTANCE_MAX
ESoundSpatializationAlgorithm* {.size: sizeof(uint8), pure.} = enum
SPATIALIZATION_Default, SPATIALIZATION_HRTF, SPATIALIZATION_MAX
EAirAbsorptionMethod* {.size: sizeof(uint8), pure.} = enum
Linear, CustomCurve, EAirAbsorptionMethod_MAX
EReverbSendMethod* {.size: sizeof(uint8), pure.} = enum
Linear, CustomCurve, Manual, EReverbSendMethod_MAX
ESubmixSendMethod* {.size: sizeof(uint8), pure.} = enum
Linear, CustomCurve, Manual, ESubmixSendMethod_MAX
EPriorityAttenuationMethod* {.size: sizeof(uint8), pure.} = enum
Linear, CustomCurve, Manual, EPriorityAttenuationMethod_MAX
ESoundGroup* {.size: sizeof(uint8), pure.} = enum
SOUNDGROUP_Default, SOUNDGROUP_Effects, SOUNDGROUP_UI, SOUNDGROUP_Music,
SOUNDGROUP_Voice, SOUNDGROUP_GameSoundGroup1, SOUNDGROUP_GameSoundGroup2,
SOUNDGROUP_GameSoundGroup3, SOUNDGROUP_GameSoundGroup4,
SOUNDGROUP_GameSoundGroup5, SOUNDGROUP_GameSoundGroup6,
SOUNDGROUP_GameSoundGroup7, SOUNDGROUP_GameSoundGroup8,
SOUNDGROUP_GameSoundGroup9, SOUNDGROUP_GameSoundGroup10,
SOUNDGROUP_GameSoundGroup11, SOUNDGROUP_GameSoundGroup12,
SOUNDGROUP_GameSoundGroup13, SOUNDGROUP_GameSoundGroup14,
SOUNDGROUP_GameSoundGroup15, SOUNDGROUP_GameSoundGroup16,
SOUNDGROUP_GameSoundGroup17, SOUNDGROUP_GameSoundGroup18,
SOUNDGROUP_GameSoundGroup19, SOUNDGROUP_GameSoundGroup20, SOUNDGROUP_MAX
ModulationParamMode* {.size: sizeof(uint8), pure.} = enum
MPM_Normal, MPM_Abs, MPM_Direct, MPM_MAX
ESourceBusSendLevelControlMethod* {.size: sizeof(uint8), pure.} = enum
Linear, CustomCurve, Manual, ESourceBusSendLevelControlMethod_MAX
EDecompressionType* {.size: sizeof(uint8), pure.} = enum
DTYPE_Setup, DTYPE_Invalid, DTYPE_Preview, DTYPE_Native, DTYPE_RealTime,
DTYPE_Procedural, DTYPE_Xenon, DTYPE_Streaming, DTYPE_MAX
ESoundWaveFFTSize* {.size: sizeof(uint8), pure.} = enum
VerySmall_64, Small_256, Medium_512, Large_1024, VeryLarge_2048,
ESoundWaveFFTSize_MAX
ESoundAssetCompressionType* {.size: sizeof(uint8), pure.} = enum
BinkAudio, ADPCM, PCM, PlatformSpecific, ProjectDefined,
ESoundAssetCompressionType_MAX
ESoundWaveLoadingBehavior* {.size: sizeof(uint8), pure.} = enum
Inherited, RetainOnLoad, PrimeOnLoad, LoadOnDemand, ForceInline,
Uninitialized, ESoundWaveLoadingBehavior_MAX
ENormalMode* {.size: sizeof(uint8), pure.} = enum
NM_PreserveSmoothingGroups, NM_RecalculateNormals,
NM_RecalculateNormalsSmooth, NM_RecalculateNormalsHard, TEMP_BROKEN,
ENormalMode_MAX
EImportanceLevel* {.size: sizeof(uint8), pure.} = enum
IL_Off, IL_Lowest, IL_Low, IL_Normal, IL_High, IL_Highest, TEMP_BROKEN2,
EImportanceLevel_MAX
EOptimizationType* {.size: sizeof(uint8), pure.} = enum
OT_NumOfTriangles, OT_MaxDeviation, OT_MAX
EStereoLayerType* {.size: sizeof(uint8), pure.} = enum
SLT_WorldLocked, SLT_TrackerLocked, SLT_FaceLocked, SLT_MAX
EStereoLayerShape* {.size: sizeof(uint8), pure.} = enum
SLSH_QuadLayer, SLSH_CylinderLayer, SLSH_CubemapLayer, SLSH_EquirectLayer,
SLSH_MAX
ESubUVBoundingVertexCount* {.size: sizeof(uint8), pure.} = enum
BVC_FourVertices, BVC_EightVertices, BVC_MAX
EOpacitySourceMode* {.size: sizeof(uint8), pure.} = enum
OSM_Alpha, OSM_ColorBrightness, OSM_RedChannel, OSM_GreenChannel,
OSM_BlueChannel, OSM_MAX
EHorizTextAligment* {.size: sizeof(uint8), pure.} = enum
EHTA_Left, EHTA_Center, EHTA_Right, EHTA_MAX
EVerticalTextAligment* {.size: sizeof(uint8), pure.} = enum
EVRTA_TextTop, EVRTA_TextCenter, EVRTA_TextBottom, EVRTA_QuadTop, EVRTA_MAX
TextureFilter* {.size: sizeof(uint8), pure.} = enum
TF_Nearest, TF_Bilinear, TF_Trilinear, TF_Default, TF_MAX
TextureAddress* {.size: sizeof(uint8), pure.} = enum
TA_Wrap, TA_Clamp, TA_Mirror, TA_MAX
ETextureMipCount* {.size: sizeof(uint8), pure.} = enum
TMC_ResidentMips, TMC_AllMips, TMC_AllMipsBiased, TMC_MAX
ETextureCompressionQuality* {.size: sizeof(uint8), pure.} = enum
TCQ_Default, TCQ_Lowest, TCQ_Low, TCQ_Medium, TCQ_High, TCQ_Highest, TCQ_MAX
TextureGroup* {.size: sizeof(uint8), pure.} = enum
TEXTUREGROUP_World, TEXTUREGROUP_WorldNormalMap, TEXTUREGROUP_WorldSpecular,
TEXTUREGROUP_Character, TEXTUREGROUP_CharacterNormalMap,
TEXTUREGROUP_CharacterSpecular, TEXTUREGROUP_Weapon,
TEXTUREGROUP_WeaponNormalMap, TEXTUREGROUP_WeaponSpecular,
TEXTUREGROUP_Vehicle, TEXTUREGROUP_VehicleNormalMap,
TEXTUREGROUP_VehicleSpecular, TEXTUREGROUP_Cinematic, TEXTUREGROUP_Effects,
TEXTUREGROUP_EffectsNotFiltered, TEXTUREGROUP_Skybox, TEXTUREGROUP_UI,
TEXTUREGROUP_Lightmap, TEXTUREGROUP_RenderTarget,
TEXTUREGROUP_MobileFlattened, TEXTUREGROUP_ProcBuilding_Face,
TEXTUREGROUP_ProcBuilding_LightMap, TEXTUREGROUP_Shadowmap,
TEXTUREGROUP_ColorLookupTable, TEXTUREGROUP_Terrain_Heightmap,
TEXTUREGROUP_Terrain_Weightmap, TEXTUREGROUP_Bokeh,
TEXTUREGROUP_IESLightProfile, TEXTUREGROUP_Pixels2D,
TEXTUREGROUP_HierarchicalLOD, TEXTUREGROUP_Impostor,
TEXTUREGROUP_ImpostorNormalDepth, TEXTUREGROUP_8BitData,
TEXTUREGROUP_16BitData, TEXTUREGROUP_Project01, TEXTUREGROUP_Project02,
TEXTUREGROUP_Project03, TEXTUREGROUP_Project04, TEXTUREGROUP_Project05,
TEXTUREGROUP_Project06, TEXTUREGROUP_Project07, TEXTUREGROUP_Project08,
TEXTUREGROUP_Project09, TEXTUREGROUP_Project10, TEXTUREGROUP_Project11,
TEXTUREGROUP_Project12, TEXTUREGROUP_Project13, TEXTUREGROUP_Project14,
TEXTUREGROUP_Project15, TEXTUREGROUP_Project16, TEXTUREGROUP_Project17,
TEXTUREGROUP_Project18, TEXTUREGROUP_MAX
TextureMipGenSettings* {.size: sizeof(uint8), pure.} = enum
TMGS_FromTextureGroup, TMGS_SimpleAverage, TMGS_Sharpen0, TMGS_Sharpen1,
TMGS_Sharpen2, TMGS_Sharpen3, TMGS_Sharpen4, TMGS_Sharpen5, TMGS_Sharpen6,
TMGS_Sharpen7, TMGS_Sharpen8, TMGS_Sharpen9, TMGS_Sharpen10, TMGS_NoMipmaps,
TMGS_LeaveExistingMips, TMGS_Blur1, TMGS_Blur2, TMGS_Blur3, TMGS_Blur4,
TMGS_Blur5, TMGS_Unfiltered, TMGS_Angular, TMGS_MAX
ETexturePowerOfTwoSetting* {.size: sizeof(uint8), pure.} = enum
None, PadToPowerOfTwo, PadToSquarePowerOfTwo, ETexturePowerOfTwoSetting_MAX
ETextureSamplerFilter* {.size: sizeof(uint8), pure.} = enum
Point, Bilinear, Trilinear, AnisotropicPoint, AnisotropicLinear,
ETextureSamplerFilter_MAX
ETextureMipLoadOptions* {.size: sizeof(uint8), pure.} = enum
Default, AllMips, OnlyFirstMip, ETextureMipLoadOptions_MAX
ETextureDownscaleOptions* {.size: sizeof(uint8), pure.} = enum
Default, Unfiltered, SimpleAverage, Sharpen0, Sharpen1, Sharpen2, Sharpen3,
Sharpen4, Sharpen5, Sharpen6, Sharpen7, Sharpen8, Sharpen9, Sharpen10,
ETextureDownscaleOptions_MAX
ETextureLossyCompressionAmount* {.size: sizeof(uint8), pure.} = enum
TLCA_Default, TLCA_None, TLCA_Lowest, TLCA_Low, TLCA_Medium, TLCA_High,
TLCA_Highest, TLCA_MAX
ETextureEncodeSpeed* {.size: sizeof(uint8), pure.} = enum
Final, FinalIfAvailable, Fast, ETextureEncodeSpeed_MAX
ETextureClass* {.size: sizeof(uint8), pure.} = enum
Invalid, TwoD, Cube, Array, CubeArray, Volume, TwoDDynamic, RenderTarget,
Other2DNoSource, OtherUnknown, ETextureClass_MAX
ECompositeTextureMode* {.size: sizeof(uint8), pure.} = enum
CTM_Disabled, CTM_NormalRoughnessToRed, CTM_NormalRoughnessToGreen,
CTM_NormalRoughnessToBlue, CTM_NormalRoughnessToAlpha, CTM_MAX
ETextureSourceCompressionFormat* {.size: sizeof(uint8), pure.} = enum
TSCF_None, TSCF_PNG, TSCF_JPEG, TSCF_MAX
ETextureSourceFormat* {.size: sizeof(uint8), pure.} = enum
TSF_Invalid, TSF_G8, TSF_BGRA8, TSF_BGRE8, TSF_RGBA16, TSF_RGBA16F,
TSF_RGBA8_DEPRECATED, TSF_RGBE8_DEPRECATED, TSF_G16, TSF_RGBA32F, TSF_R16F,
TSF_R32F, TSF_MAX, TSF_RGBA8, TSF_RGBE8
TextureCompressionSettings* {.size: sizeof(uint8), pure.} = enum
TC_Default, TC_Normalmap, TC_Masks, TC_Grayscale, TC_Displacementmap,
TC_VectorDisplacementmap, TC_HDR, TC_EditorIcon, TC_Alpha,
TC_DistanceFieldFont, TC_HDR_Compressed, TC_BC7, TC_HalfFloat, TC_LQ,
TC_EncodedReflectionCapture, TC_SingleFloat, TC_HDR_F32, TC_MAX
ETextureSourceEncoding* {.size: sizeof(uint8), pure.} = enum
TSE_None, TSE_Linear, TSE_sRGB, TSE_ST2084, TSE_Gamma22, TSE_BT1886,
TSE_Gamma26, TSE_Cineon, TSE_REDLog, TSE_REDLog3G10, TSE_SLog1, TSE_SLog2,
TSE_SLog3, TSE_AlexaV3LogC, TSE_CanonLog, TSE_ProTune, TSE_VLog, TSE_MAX
ETextureColorSpace* {.size: sizeof(uint8), pure.} = enum
TCS_None, TCS_sRGB, TCS_Rec2020, TCS_ACESAP0, TCS_ACESAP1, TCS_P3DCI,
TCS_P3D65, TCS_REDWideGamut, TCS_SonySGamut3, TCS_SonySGamut3Cine,
TCS_AlexaWideGamut, TCS_CanonCinemaGamut, TCS_GoProProtuneNative,
TCS_PanasonicVGamut, TCS_Custom, TCS_MAX
ETextureChromaticAdaptationMethod* {.size: sizeof(uint8), pure.} = enum
TCAM_None, TCAM_Bradford, TCAM_CAT02, TCAM_MAX
ETextureRenderTargetFormat* {.size: sizeof(uint8), pure.} = enum
RTF_R8, RTF_RG8, RTF_RGBA8, RTF_RGBA8_SRGB, RTF_R16f, RTF_RG16f,
RTF_RGBA16f, RTF_R32f, RTF_RG32f, RTF_RGBA32f, RTF_RGB10A2, RTF_MAX
ETimelineLengthMode* {.size: sizeof(uint8), pure.} = enum
TL_TimelineLength, TL_LastKeyFrame, TL_MAX
ETimelineDirection* {.size: sizeof(uint8), pure.} = enum
Forward, Backward, ETimelineDirection_MAX
ETwitterRequestMethod* {.size: sizeof(uint8), pure.} = enum
TRM_Get, TRM_Post, TRM_Delete, TRM_MAX
ETwitterIntegrationDelegate* {.size: sizeof(uint8), pure.} = enum
TID_AuthorizeComplete, TID_TweetUIComplete, TID_RequestComplete, TID_MAX
EUserDefinedStructureStatus* {.size: sizeof(uint8), pure.} = enum
UDSS_UpToDate, UDSS_Dirty, UDSS_Error, UDSS_Duplicate, UDSS_MAX
EVectorFieldConstructionOp* {.size: sizeof(uint8), pure.} = enum
VFCO_Extrude, VFCO_Revolve, VFCO_MAX
ESplitScreenType* {.size: sizeof(uint8), pure.} = enum
None, TwoPlayer_Horizontal, TwoPlayer_Vertical, ThreePlayer_FavorTop,
ThreePlayer_FavorBottom, ThreePlayer_Vertical, ThreePlayer_Horizontal,
FourPlayer_Grid, FourPlayer_Vertical, FourPlayer_Horizontal, SplitTypeCount,
ESplitScreenType_MAX
EWindSourceType* {.size: sizeof(uint8), pure.} = enum
Directional, Point, EWindSourceType_MAX
EStreamingSourceTargetState* {.size: sizeof(uint8), pure.} = enum
Loaded, Activated, EStreamingSourceTargetState_MAX
EStreamingSourcePriority* {.size: sizeof(uint8), pure.} = enum
Highest, High, Normal, Low, Lowest, Default, EStreamingSourcePriority_MAX
EVisibilityAggressiveness* {.size: sizeof(uint8), pure.} = enum
VIS_LeastAggressive, VIS_ModeratelyAggressive, VIS_MostAggressive, VIS_Max
EVolumeLightingMethod* {.size: sizeof(uint8), pure.} = enum
VLM_VolumetricLightmap, VLM_SparseVolumeLightingSamples, VLM_MAX
EHierarchicalSimplificationMethod* {.size: sizeof(uint8), pure.} = enum
None, Merge, Simplify, Approximate, EHierarchicalSimplificationMethod_MAX
EQuartzTimeSignatureQuantization* {.size: sizeof(uint8), pure.} = enum
HalfNote, QuarterNote, EighthNote, SixteenthNote, ThirtySecondNote, Count,
EQuartzTimeSignatureQuantization_MAX
EQuartzDelegateType* {.size: sizeof(uint8), pure.} = enum
MetronomeTick, CommandEvent, Count, EQuartzDelegateType_MAX
EQuarztQuantizationReference* {.size: sizeof(uint8), pure.} = enum
BarRelative, TransportRelative, CurrentTimeRelative, Count,
EQuarztQuantizationReference_MAX
EQuartzCommandType* {.size: sizeof(uint8), pure.} = enum
PlaySound, QueueSoundToPlay, RetriggerSound, TickRateChange, TransportReset,
StartOtherClock, Custom, EQuartzCommandType_MAX
EActorUpdateOverlapsMethod* {.size: sizeof(uint8), pure.} = enum
UseConfigDefault, AlwaysUpdate, OnlyUpdateMovable, NeverUpdate,
EActorUpdateOverlapsMethod_MAX
EActorGridPlacement* {.size: sizeof(uint8), pure.} = enum
Bounds, Location, AlwaysLoaded, None, EActorGridPlacement_MAX
FNavigationSystemRunMode* {.size: sizeof(uint8), pure.} = enum
InvalidMode, GameMode, EditorMode, SimulationMode, PIEMode,
InferFromWorldMode, EditorWorldPartitionBuildMode,
FNavigationSystemRunMode_MAX
ENavigationOptionFlag* {.size: sizeof(uint8), pure.} = enum
Default, Enable, Disable, MAX
ENavDataGatheringMode* {.size: sizeof(uint8), pure.} = enum
Default, Instant, Lazy, ENavDataGatheringMode_MAX
ENavDataGatheringModeConfig* {.size: sizeof(uint8), pure.} = enum
Invalid, Instant, Lazy, ENavDataGatheringModeConfig_MAX
ENavigationQueryResult* {.size: sizeof(uint8), pure.} = enum
Invalid, Error, Fail, Success, ENavigationQueryResult_MAX
EAlphaBlendOption* {.size: sizeof(uint8), pure.} = enum
Linear, Cubic, HermiteCubic, Sinusoidal, QuadraticInOut, CubicInOut,
QuarticInOut, QuinticInOut, CircularIn, CircularOut, CircularInOut, ExpIn,
ExpOut, ExpInOut, Custom, EAlphaBlendOption_MAX
EAnimGroupRole* {.size: sizeof(uint8), pure.} = enum
CanBeLeader, AlwaysFollower, AlwaysLeader, TransitionLeader,
TransitionFollower, EAnimGroupRole_MAX
EAnimSyncGroupScope* {.size: sizeof(uint8), pure.} = enum
Local, Component, EAnimSyncGroupScope_MAX
EAnimSyncMethod* {.size: sizeof(uint8), pure.} = enum
DoNotSync, SyncGroup, Graph, EAnimSyncMethod_MAX
EAnimExecutionContextConversionResult* {.size: sizeof(uint8), pure.} = enum
Succeeded, Failed, EAnimExecutionContextConversionResult_MAX
EMontagePlayReturnType* {.size: sizeof(uint8), pure.} = enum
MontageLength, Duration, EMontagePlayReturnType_MAX
EDrawDebugItemType* {.size: sizeof(uint8), pure.} = enum
DirectionalArrow, Sphere, Line, OnScreenMessage, CoordinateSystem, Point,
Circle, Cone, EDrawDebugItemType_MAX
EAnimLinkMethod* {.size: sizeof(uint8), pure.} = enum
Absolute, Relative, Proportional, EAnimLinkMethod_MAX
EAnimNotifyEventType* {.size: sizeof(uint8), pure.} = enum
Begin, End, EAnimNotifyEventType_MAX
EMontageBlendMode* {.size: sizeof(uint8), pure.} = enum
Standard, Inertialization, EMontageBlendMode_MAX
EMontageSubStepResult* {.size: sizeof(uint8), pure.} = enum
Moved, NotMoved, InvalidSection, InvalidMontage, EMontageSubStepResult_MAX
EPinHidingMode* {.size: sizeof(uint8), pure.} = enum
NeverAsPin, PinHiddenByDefault, PinShownByDefault, AlwaysAsPin,
EPinHidingMode_MAX
EAnimNodeDataFlags* {.size: sizeof(uint8), pure.} = enum
None, HasInitialUpdateFunction, HasBecomeRelevantFunction,
HasUpdateFunction, EAnimNodeDataFlags_MAX
EAnimNodeReferenceConversionResult* {.size: sizeof(uint8), pure.} = enum
Succeeded, Failed, EAnimNodeReferenceConversionResult_MAX
EInertializationState* {.size: sizeof(uint8), pure.} = enum
Inactive, Pending, Active, EInertializationState_MAX
EInertializationBoneState* {.size: sizeof(uint8), pure.} = enum
Invalid, Valid, Excluded, EInertializationBoneState_MAX
EInertializationSpace* {.size: sizeof(uint8), pure.} = enum
Default, WorldSpace, WorldRotation, EInertializationSpace_MAX
EEvaluatorDataSource* {.size: sizeof(uint8), pure.} = enum
EDS_SourcePose, EDS_DestinationPose, EDS_MAX
EEvaluatorMode* {.size: sizeof(uint8), pure.} = enum
EM_Standard, EM_Freeze, EM_DelayedFreeze, EM_MAX
ETransitionRequestQueueMode* {.size: sizeof(uint8), pure.} = enum
Shared, Unique, ETransitionRequestQueueMode_MAX
ETransitionRequestOverwriteMode* {.size: sizeof(uint8), pure.} = enum
Append, Ignore, Overwrite, ETransitionRequestOverwriteMode_MAX
ETransitionBlendMode* {.size: sizeof(uint8), pure.} = enum
TBM_Linear, TBM_Cubic, TBM_MAX
ETransitionLogicType* {.size: sizeof(uint8), pure.} = enum
TLT_StandardBlend, TLT_Inertialization, TLT_Custom, TLT_MAX
EAnimPropertyAccessCallSite* {.size: sizeof(uint8), pure.} = enum
WorkerThread_Unbatched, WorkerThread_Batched_PreEventGraph,
WorkerThread_Batched_PostEventGraph, GameThread_Batched_PreEventGraph,
GameThread_Batched_PostEventGraph, EAnimPropertyAccessCallSite_MAX
EBlendProfileMode* {.size: sizeof(uint8), pure.} = enum
TimeFactor, WeightFactor, BlendMask, EBlendProfileMode_MAX
ETransformCurveChannel* {.size: sizeof(uint8), pure.} = enum
Position, Rotation, Scale, Invalid, ETransformCurveChannel_MAX
EVectorCurveChannel* {.size: sizeof(uint8), pure.} = enum
X, Y, Z, Invalid, EVectorCurveChannel_MAX
EPostCopyOperation* {.size: sizeof(uint8), pure.} = enum
None, LogicalNegateBool, EPostCopyOperation_MAX
EAnimAlphaInputType* {.size: sizeof(uint8), pure.} = enum
Float, Bool, Curve, EAnimAlphaInputType_MAX
EMirrorRowType* {.size: sizeof(uint8), pure.} = enum
Bone, AnimationNotify, Curve, SyncMarker, Custom, EMirrorRowType_MAX
EMirrorFindReplaceMethod* {.size: sizeof(uint8), pure.} = enum
Prefix, Suffix, RegularExpression, EMirrorFindReplaceMethod_MAX
ETrajectorySampleDomain* {.size: sizeof(uint8), pure.} = enum
None, Time, Distance, ETrajectorySampleDomain_MAX
EControlConstraint* {.size: sizeof(uint8), pure.} = enum
Orientation, Translation, MAX
EConstraintTransform* {.size: sizeof(uint8), pure.} = enum
Absolute, Relative, EConstraintTransform_MAX
EBoneTranslationRetargetingMode* {.size: sizeof(uint8), pure.} = enum
Animation, Skeleton, AnimationScaled, AnimationRelative, OrientAndScale,
EBoneTranslationRetargetingMode_MAX
ETimeStretchCurveMapping* {.size: sizeof(uint8), pure.} = enum
T_Original, T_TargetMin, T_TargetMax, MAX
EPreviewAnimationBlueprintApplicationMethod* {.size: sizeof(uint8), pure.} = enum
LinkedLayers, LinkedAnimGraph,
EPreviewAnimationBlueprintApplicationMethod_MAX
EPrimaryAssetCookRule* {.size: sizeof(uint8), pure.} = enum
Unknown, NeverCook, DevelopmentCook, DevelopmentAlwaysCook, AlwaysCook,
EPrimaryAssetCookRule_MAX
EAttenuationDistanceModel* {.size: sizeof(uint8), pure.} = enum
Linear, Logarithmic, Inverse, LogReverse, NaturalSound, Custom,
EAttenuationDistanceModel_MAX
EAttenuationShape* {.size: sizeof(uint8), pure.} = enum
Sphere, Capsule, Box, Cone, EAttenuationShape_MAX
ENaturalSoundFalloffMode* {.size: sizeof(uint8), pure.} = enum
Continues, Silent, Hold, ENaturalSoundFalloffMode_MAX
EAudioBusChannels* {.size: sizeof(uint8), pure.} = enum
Mono, Stereo, Quad, FivePointOne, SevenPointOne, EAudioBusChannels_MAX
EVoiceSampleRate* {.size: sizeof(uint8), pure.} = enum
Low16000Hz, Normal24000Hz, EVoiceSampleRate_MAX
EPanningMethod* {.size: sizeof(uint8), pure.} = enum
Linear, EqualPower, EPanningMethod_MAX
EMonoChannelUpmixMethod* {.size: sizeof(uint8), pure.} = enum
Linear, EqualPower, FullVolume, EMonoChannelUpmixMethod_MAX
EDefaultAudioCompressionType* {.size: sizeof(uint8), pure.} = enum
BinkAudio, ADPCM, PCM, PlatformSpecific, EDefaultAudioCompressionType_MAX
EAudioVolumeLocationState* {.size: sizeof(uint8), pure.} = enum
InsideTheVolume, OutsideTheVolume, EAudioVolumeLocationState_MAX
EInterfaceValidResult* {.size: sizeof(uint8), pure.} = enum
Valid, Invalid, EInterfaceValidResult_MAX
ECameraShakeUpdateResultFlags* {.size: sizeof(uint8), pure.} = enum
ApplyAsAbsolute, SkipAutoScale, SkipAutoPlaySpace, Default,
ECameraShakeUpdateResultFlags_MAX
ECameraShakeDurationType* {.size: sizeof(uint8), pure.} = enum
Fixed, Infinite, Custom, ECameraShakeDurationType_MAX
ECameraShakeAttenuation* {.size: sizeof(uint8), pure.} = enum
Linear, Quadratic, ECameraShakeAttenuation_MAX
ECameraAlphaBlendMode* {.size: sizeof(uint8), pure.} = enum
CABM_Linear, CABM_Cubic, CABM_MAX
EAudioFaderCurve* {.size: sizeof(uint8), pure.} = enum
Linear, Logarithmic, SCurve, Sin, Count, EAudioFaderCurve_MAX
EChildActorComponentTreeViewVisualizationMode* {.size: sizeof(uint8), pure.} = enum
UseDefault, ComponentOnly, ComponentWithChildActor, ChildActorOnly,
EChildActorComponentTreeViewVisualizationMode_MAX
EControllerAnalogStick* {.size: sizeof(uint8), pure.} = enum
CAS_LeftStick, CAS_RightStick, CAS_MAX
ESyncOption* {.size: sizeof(uint8), pure.} = enum
Drive, Passive, Disabled, ESyncOption_MAX
EReflectionSourceType* {.size: sizeof(uint8), pure.} = enum
CapturedScene, SpecifiedCubemap, EReflectionSourceType_MAX
ESceneCapturePrimitiveRenderMode* {.size: sizeof(uint8), pure.} = enum
PRM_LegacySceneCapture, PRM_RenderScenePrimitives, PRM_UseShowOnlyList,
PRM_MAX
EAnimCurveType* {.size: sizeof(uint8), pure.} = enum
AttributeCurve, MaterialCurve, MorphTargetCurve, MaxAnimCurveType,
EAnimCurveType_MAX
ECustomBoneAttributeLookup* {.size: sizeof(uint8), pure.} = enum
BoneOnly, ImmediateParent, ParentHierarchy, ECustomBoneAttributeLookup_MAX
EKinematicBonesUpdateToPhysics* {.size: sizeof(uint8), pure.} = enum
SkipSimulatingBones, SkipAllBones, EKinematicBonesUpdateToPhysics_MAX
EAnimationMode* {.size: sizeof(uint8), pure.} = enum
AnimationBlueprint, AnimationSingleNode, AnimationCustomMode,
EAnimationMode_MAX
EPhysicsTransformUpdateMode* {.size: sizeof(uint8), pure.} = enum
SimulationUpatesComponentTransform, ComponentTransformIsKinematic,
EPhysicsTransformUpdateMode_MAX
ESkyAtmosphereTransformMode* {.size: sizeof(uint8), pure.} = enum
PlanetTopAtAbsoluteWorldOrigin, PlanetTopAtComponentTransform,
PlanetCenterAtComponentTransform, ESkyAtmosphereTransformMode_MAX
ESplinePointType* {.size: sizeof(uint8), pure.} = enum
Linear, Curve, Constant, CurveClamped, CurveCustomTangent,
ESplinePointType_MAX
ESplineCoordinateSpace* {.size: sizeof(uint8), pure.} = enum
Local, World, ESplineCoordinateSpace_MAX
ESplineMeshAxis* {.size: sizeof(uint8), pure.} = enum
X, Y, Z, ESplineMeshAxis_MAX
EVolumetricCloudTracingMaxDistanceMode* {.size: sizeof(uint8), pure.} = enum
DistanceFromCloudLayerEntryPoint, DistanceFromPointOfView,
EVolumetricCloudTracingMaxDistanceMode_MAX
ECurveTableMode* {.size: sizeof(uint8), pure.} = enum
Empty, SimpleCurves, RichCurves, ECurveTableMode_MAX
FDataDrivenCVarType* {.size: sizeof(uint8), pure.} = enum
CVarFloat, CVarInt, CVarBool, FDataDrivenCVarType_MAX
EEvaluateCurveTableResult* {.size: sizeof(uint8), pure.} = enum
RowFound, RowNotFound, EEvaluateCurveTableResult_MAX
EReporterLineStyle* {.size: sizeof(uint8), pure.} = enum
Line, Dash, EReporterLineStyle_MAX
EGraphAxisStyle* {.size: sizeof(uint8), pure.} = enum
Lines, Notches, Grid, EGraphAxisStyle_MAX
EGraphDataStyle* {.size: sizeof(uint8), pure.} = enum
Lines, Filled, EGraphDataStyle_MAX
ELegendPosition* {.size: sizeof(uint8), pure.} = enum
Outside, Inside, ELegendPosition_MAX
EGrammaticalGender* {.size: sizeof(uint8), pure.} = enum
Neuter, Masculine, Feminine, Mixed, EGrammaticalGender_MAX
EGrammaticalNumber* {.size: sizeof(uint8), pure.} = enum
Singular, Plural, EGrammaticalNumber_MAX
ETypedElementWorldType* {.size: sizeof(uint8), pure.} = enum
Game, Editor, ETypedElementWorldType_MAX
ECustomTimeStepSynchronizationState* {.size: sizeof(uint8), pure.} = enum
Closed, Error, Synchronized, Synchronizing,
ECustomTimeStepSynchronizationState_MAX
EVectorQuantization* {.size: sizeof(uint8), pure.} = enum
RoundWholeNumber, RoundOneDecimal, RoundTwoDecimals, EVectorQuantization_MAX
ERotatorQuantization* {.size: sizeof(uint8), pure.} = enum
ByteComponents, ShortComponents, ERotatorQuantization_MAX
ETimecodeProviderSynchronizationState* {.size: sizeof(uint8), pure.} = enum
Closed, Error, Synchronized, Synchronizing,
ETimecodeProviderSynchronizationState_MAX
EFontCacheType* {.size: sizeof(uint8), pure.} = enum
Offline, Runtime, EFontCacheType_MAX
ERootMotionAccumulateMode* {.size: sizeof(uint8), pure.} = enum
Override, Additive, ERootMotionAccumulateMode_MAX
ERootMotionSourceStatusFlags* {.size: sizeof(uint8), pure.} = enum
Prepared, Finished, MarkedForRemoval, ERootMotionSourceStatusFlags_MAX
ERootMotionSourceSettingsFlags* {.size: sizeof(uint8), pure.} = enum
UseSensitiveLiftoffCheck, DisablePartialEndTick, IgnoreZAccumulate,
ERootMotionSourceSettingsFlags_MAX
ERootMotionFinishVelocityMode* {.size: sizeof(uint8), pure.} = enum
MaintainLastRootMotionVelocity, SetVelocity, ClampVelocity,
ERootMotionFinishVelocityMode_MAX
EWindowMode* {.size: sizeof(uint8), pure.} = enum
Fullscreen, WindowedFullscreen, Windowed, EWindowMode_MAX
ESlateGesture* {.size: sizeof(uint8), pure.} = enum
None, Scroll, Magnify, Swipe, Rotate, LongPress, ESlateGesture_MAX
EMIDCreationFlags* {.size: sizeof(uint8), pure.} = enum
None, Transient, EMIDCreationFlags_MAX
EEasingFunc* {.size: sizeof(uint8), pure.} = enum
Linear, Step, SinusoidalIn, SinusoidalOut, SinusoidalInOut, EaseIn, EaseOut,
EaseInOut, ExpoIn, ExpoOut, ExpoInOut, CircularIn, CircularOut,
CircularInOut, EEasingFunc_MAX
ELerpInterpolationMode* {.size: sizeof(uint8), pure.} = enum
QuatInterp, EulerInterp, DualQuatInterp, ELerpInterpolationMode_MAX
EMatrixColumns* {.size: sizeof(uint8), pure.} = enum
First, Second, Third, Fourth, EMatrixColumns_MAX
EImportanceWeight* {.size: sizeof(uint8), pure.} = enum
Luminance, Red, Green, Blue, Alpha, EImportanceWeight_MAX
EActorPackagingScheme* {.size: sizeof(uint8), pure.} = enum
Original, Reduced, EActorPackagingScheme_MAX
EMeshFeatureImportance* {.size: sizeof(uint8), pure.} = enum
Off, Lowest, Low, Normal, High, Highest, EMeshFeatureImportance_MAX
EStaticMeshReductionTerimationCriterion* {.size: sizeof(uint8), pure.} = enum
Triangles, Vertices, Any, EStaticMeshReductionTerimationCriterion_MAX
ELandscapeCullingPrecision* {.size: sizeof(uint8), pure.} = enum
High, Medium, Low, ELandscapeCullingPrecision_MAX
EProxyNormalComputationMethod* {.size: sizeof(uint8), pure.} = enum
AngleWeighted, AreaWeighted, EqualWeighted,
EProxyNormalComputationMethod_MAX
EMeshLODSelectionType* {.size: sizeof(uint8), pure.} = enum
AllLODs, SpecificLOD, CalculateLOD, LowestDetailLOD,
EMeshLODSelectionType_MAX
EMeshMergeType* {.size: sizeof(uint8), pure.} = enum
MeshMergeType_Default, MeshMergeType_MergeActor, MeshMergeType_MAX
EUVOutput* {.size: sizeof(uint8), pure.} = enum
DoNotOutputChannel, OutputChannel, EUVOutput_MAX
EMeshApproximationType* {.size: sizeof(uint8), pure.} = enum
MeshAndMaterials, MeshShapeOnly, EMeshApproximationType_MAX
EMeshApproximationBaseCappingType* {.size: sizeof(uint8), pure.} = enum
NoBaseCapping, ConvexPolygon, ConvexSolid,
EMeshApproximationBaseCappingType_MAX
EOccludedGeometryFilteringPolicy* {.size: sizeof(uint8), pure.} = enum
NoOcclusionFiltering, VisibilityBasedFiltering,
EOccludedGeometryFilteringPolicy_MAX
EMeshApproximationSimplificationPolicy* {.size: sizeof(uint8), pure.} = enum
FixedTriangleCount, TrianglesPerArea, GeometricTolerance,
EMeshApproximationSimplificationPolicy_MAX
EMeshApproximationGroundPlaneClippingPolicy* {.size: sizeof(uint8), pure.} = enum
NoGroundClipping, DiscardWithZPlane, CutWithZPlane, CutAndFillWithZPlane,
EMeshApproximationGroundPlaneClippingPolicy_MAX
EMeshApproximationUVGenerationPolicy* {.size: sizeof(uint8), pure.} = enum
PreferUVAtlas, PreferXAtlas, PreferPatchBuilder,
EMeshApproximationUVGenerationPolicy_MAX
EVertexPaintAxis* {.size: sizeof(uint8), pure.} = enum
X, Y, Z, EVertexPaintAxis_MAX
EPSCPoolMethod* {.size: sizeof(uint8), pure.} = enum
None, AutoRelease, ManualRelease, ManualRelease_OnComplete, FreeInPool,
EPSCPoolMethod_MAX
EPerQualityLevels* {.size: sizeof(uint8), pure.} = enum
Low, Medium, High, Epic, Cinematic, Num, EPerQualityLevels_MAX
EDOFMode* {.size: sizeof(uint8), pure.} = enum
Default, SixDOF, YZPlane, XZPlane, XYPlane, CustomPlane, None, EDOFMode_MAX
EAngularDriveMode* {.size: sizeof(uint8), pure.} = enum
SLERP, TwistAndSwing, EAngularDriveMode_MAX
EConstraintTransformComponentFlags* {.size: sizeof(uint8), pure.} = enum
None, ChildPosition, ChildRotation, ParentPosition, ParentRotation,
AllChild, AllParent, AllPosition, AllRotation, All,
EConstraintTransformComponentFlags_MAX
EPhysicsAssetSolverType* {.size: sizeof(uint8), pure.} = enum
RBAN, World, EPhysicsAssetSolverType_MAX
ESettingsDOF* {.size: sizeof(uint8), pure.} = enum
Full3D, YZPlane, XZPlane, XYPlane, ESettingsDOF_MAX
ESettingsLockedAxis* {.size: sizeof(uint8), pure.} = enum
None, X, Y, Z, Invalid, ESettingsLockedAxis_MAX
EDynamicForceFeedbackAction* {.size: sizeof(uint8), pure.} = enum
Start, Update, Stop, EDynamicForceFeedbackAction_MAX
EVoiceBlockReasons* {.size: sizeof(uint8), pure.} = enum
None, Muted, MutedBy, Gameplay, Blocked, BlockedBy, EVoiceBlockReasons_MAX
EPropertyAccessCopyBatch* {.size: sizeof(uint8), pure.} = enum
InternalUnbatched, ExternalUnbatched, InternalBatched, ExternalBatched,
Count, EPropertyAccessCopyBatch_MAX
EPropertyAccessIndirectionType* {.size: sizeof(uint8), pure.} = enum
Offset, Object, Array, ScriptFunction, NativeFunction,
EPropertyAccessIndirectionType_MAX
EPropertyAccessObjectType* {.size: sizeof(uint8), pure.} = enum
None, Object, WeakObject, SoftObject, EPropertyAccessObjectType_MAX
EPropertyAccessCopyType* {.size: sizeof(uint8), pure.} = enum
None, Plain, Complex, Bool, Struct, Object, Name, Array, PromoteBoolToByte,
PromoteBoolToInt32, PromoteBoolToInt64, PromoteBoolToFloat,
PromoteBoolToDouble, PromoteByteToInt32, PromoteByteToInt64,
PromoteByteToFloat, PromoteByteToDouble, PromoteInt32ToInt64,
PromoteInt32ToFloat, PromoteInt32ToDouble, PromoteFloatToDouble,
DemoteDoubleToFloat, PromoteArrayFloatToDouble, DemoteArrayDoubleToFloat,
PromoteMapValueFloatToDouble, DemoteMapValueDoubleToFloat,
EPropertyAccessCopyType_MAX
EClearSceneOptions* {.size: sizeof(uint8), pure.} = enum
NoClear, HardwareClear, QuadAtMaxZ, EClearSceneOptions_MAX
ECompositingSampleCount* {.size: sizeof(uint8), pure.} = enum
One, Two, Four, Eight, ECompositingSampleCount_MAX
ECustomDepthStencil* {.size: sizeof(uint8), pure.} = enum
Disabled, Enabled, EnabledOnDemand, EnabledWithStencil,
ECustomDepthStencil_MAX
EEarlyZPass* {.size: sizeof(uint8), pure.} = enum
None, OpaqueOnly, OpaqueAndMasked, Auto, EEarlyZPass_MAX
EVelocityOutputPass* {.size: sizeof(uint8), pure.} = enum
DepthPass, BasePass, AfterBasePass, EVelocityOutputPass_MAX
EVertexDeformationOutputsVelocity* {.size: sizeof(uint8), pure.} = enum
Off, On, Auto, EVertexDeformationOutputsVelocity_MAX
EAlphaChannelMode* {.size: sizeof(uint8), pure.} = enum
Disabled, LinearColorSpaceOnly, AllowThroughTonemapper,
EAlphaChannelMode_MAX
EAutoExposureMethodUI* {.size: sizeof(uint8), pure.} = enum
AEM_Histogram, AEM_Basic, AEM_Manual, AEM_MAX
EDefaultBackBufferPixelFormat* {.size: sizeof(uint8), pure.} = enum
DBBPF_B8G8R8A8, DBBPF_A16B16G16R16_DEPRECATED, DBBPF_FloatRGB_DEPRECATED,
DBBPF_FloatRGBA, DBBPF_A2B10G10R10, DBBPF_MAX
EFixedFoveationLevels* {.size: sizeof(uint8), pure.} = enum
Disabled, Low, Medium, High, HighTop, EFixedFoveationLevels_MAX
EMobileAntiAliasingMethod* {.size: sizeof(uint8), pure.} = enum
None, FXAA, TemporalAA, MSAA, EMobileAntiAliasingMethod_MAX
EMobileFloatPrecisionMode* {.size: sizeof(uint8), pure.} = enum
Half, Full_MaterialExpressionOnly, Full, EMobileFloatPrecisionMode_MAX
EMobileShadingPath* {.size: sizeof(uint8), pure.} = enum
Forward, Deferred, EMobileShadingPath_MAX
EShaderCompressionFormat* {.size: sizeof(uint8), pure.} = enum
None, LZ4, Oodle, Zlib, EShaderCompressionFormat_MAX
ELumenSoftwareTracingMode* {.size: sizeof(uint8), pure.} = enum
DetailTracing, GlobalTracing, ELumenSoftwareTracingMode_MAX
ELumenRayLightingMode* {.size: sizeof(uint8), pure.} = enum
SurfaceCache, HitLighting, ELumenRayLightingMode_MAX
EWorkingColorSpace* {.size: sizeof(uint8), pure.} = enum
sRGB, Rec2020, ACESAP0, ACESAP1, P3DCI, P3D65, Custom,
EWorkingColorSpace_MAX
ESkeletalMeshAsyncProperties* {.size: sizeof(uint8), pure.} = enum
None, Materials, Skeleton, RefSkeleton, RetargetBasePose, RefBasesInvMatrix,
MeshClothingAssets, UseLegacyMeshDerivedDataKey, HasActiveClothingAssets,
LODSettings, HasVertexColors, VertexColorGuid, MorphTargets,
SkeletalMeshRenderData, MeshEditorDataObject, NeverStream,
OverrideLODStreamingSettings, SupportLODStreaming, MaxNumStreamedLODs,
MaxNumOptionalLODs, ImportedModel, LODInfo, SkinWeightProfiles,
CachedComposedRefPoseMatrices, SamplingInfo, NodeMappingData,
ShadowPhysicsAsset, SkelMirrorTable, MinLod, DisableBelowMinLodStripping,
SkelMirrorAxis, SkelMirrorFlipAxis, DefaultAnimationRig,
NegativeBoundsExtension, PositiveBoundsExtension, ExtendedBounds,
HasBeenSimplified, EnablePerPolyCollision, BodySetup, MorphTargetIndexMap,
FloorOffset, ImportedBounds, PhysicsAsset, AssetImportData, ThumbnailInfo,
HasCustomDefaultEditorCamera, DefaultEditorCameraLocation,
DefaultEditorCameraRotation, RequiresLODScreenSizeConversion,
PostProcessAnimBlueprint, DefaultEditorCameraLookAt,
PreviewAttachedAssetContainer, DefaultEditorCameraOrthoZoom,
RequiresLODHysteresisConversion, bSupportRayTracing, RayTracingMinLOD,
ClothLODBiasMode, DefaultMeshDeformer, All, ESkeletalMeshAsyncProperties_MAX
EClothLODBiasMode* {.size: sizeof(uint8), pure.} = enum
MappingsToSameLOD, MappingsToMinLOD, MappingsToAnyLOD, EClothLODBiasMode_MAX
EBoneFilterActionOption* {.size: sizeof(uint8), pure.} = enum
Remove, Keep, Invalid, EBoneFilterActionOption_MAX
EVirtualizationMode* {.size: sizeof(uint8), pure.} = enum
Disabled, PlayWhenSilent, Restart, EVirtualizationMode_MAX
EMaxConcurrentResolutionRule* {.size: sizeof(uint8), pure.} = enum
PreventNew, StopOldest, StopFarthestThenPreventNew, StopFarthestThenOldest,
StopLowestPriority, StopQuietest, StopLowestPriorityThenPreventNew, Count,
EMaxConcurrentResolutionRule_MAX
EConcurrencyVolumeScaleMode* {.size: sizeof(uint8), pure.} = enum
Default, Distance, Priority, EConcurrencyVolumeScaleMode_MAX
EModulationRouting* {.size: sizeof(uint8), pure.} = enum
Disable, Inherit, Override, Union, EModulationRouting_MAX
ESourceBusChannels* {.size: sizeof(uint8), pure.} = enum
Mono, Stereo, ESourceBusChannels_MAX
EFFTSize* {.size: sizeof(uint8), pure.} = enum
DefaultSize, Min, Small, Medium, Large, VeryLarge, Max, EFFTSize_MAX
EFFTPeakInterpolationMethod* {.size: sizeof(uint8), pure.} = enum
NearestNeighbor, Linear, Quadratic, ConstantQ,
EFFTPeakInterpolationMethod_MAX
EFFTWindowType* {.size: sizeof(uint8), pure.} = enum
None, Hamming, Hann, Blackman, EFFTWindowType_MAX
EAudioSpectrumType* {.size: sizeof(uint8), pure.} = enum
MagnitudeSpectrum, PowerSpectrum, Decibel, EAudioSpectrumType_MAX
EGainParamMode* {.size: sizeof(uint8), pure.} = enum
Linear, Decibels, EGainParamMode_MAX
EAudioSpectrumBandPresetType* {.size: sizeof(uint8), pure.} = enum
KickDrum, SnareDrum, Voice, Cymbals, EAudioSpectrumBandPresetType_MAX
EAudioRecordingExportType* {.size: sizeof(uint8), pure.} = enum
SoundWave, WavFile, EAudioRecordingExportType_MAX
ESendLevelControlMethod* {.size: sizeof(uint8), pure.} = enum
Linear, CustomCurve, Manual, ESendLevelControlMethod_MAX
ESubmixSendStage* {.size: sizeof(uint8), pure.} = enum
PostDistanceAttenuation, PreDistanceAttenuation, ESubmixSendStage_MAX
ETextureEncodeEffort* {.size: sizeof(uint8), pure.} = enum
Default, Low, Normal, High, ETextureEncodeEffort_MAX
ETextureUniversalTiling* {.size: sizeof(uint8), pure.} = enum
Disabled, Enabled_256KB, Enabled_64KB, ETextureUniversalTiling_MAX
ETextureEncodeSpeedOverride* {.size: sizeof(uint8), pure.} = enum
Disabled, Final, FinalIfAvailable, Fast, ETextureEncodeSpeedOverride_MAX
ERenderFocusRule* {.size: sizeof(uint8), pure.} = enum
Always, NonPointer, NavigationOnly, Never, ERenderFocusRule_MAX
EUIScalingRule* {.size: sizeof(uint8), pure.} = enum
ShortestSide, LongestSide, Horizontal, Vertical, ScaleToFit, Custom,
EUIScalingRule_MAX
EDataLayerState* {.size: sizeof(uint8), pure.} = enum
Unloaded, Loaded, Activated, EDataLayerState_MAX
EHLODLayerType* {.size: sizeof(uint8), pure.} = enum
Instancing, MeshMerge, MeshSimplify, MeshApproximate, Custom,
EHLODLayerType_MAX
EWorldPartitionRuntimeCellState* {.size: sizeof(uint8), pure.} = enum
Unloaded, Loaded, Activated, EWorldPartitionRuntimeCellState_MAX
EWorldPartitionStreamingPerformance* {.size: sizeof(uint8), pure.} = enum
Good, Slow, Critical, EWorldPartitionStreamingPerformance_MAX
FBodyInstanceAsyncPhysicsTickHandle* {.exportcpp: "$1_".} = object
pad_0: array[8, byte]
FWalkableSlopeOverride* {.exportcpp: "$1_".} = object
walkableSlopeBehavior*: EWalkableSlopeBehavior
pad_0: array[3, byte]
walkableSlopeAngle*: float32
pad_1: array[8, byte]
FBodyInstance* {.exportcpp: "$1_".} = object
pad_0: array[89, byte]
sleepFamily*: ESleepFamily
pad_1: array[1, byte]
bUseCCD*: bool
bIgnoreAnalyticCollisions*: bool
bNotifyRigidBodyCollision*: bool
bSmoothEdgeCollisions*: bool
bInertiaConditioning*: bool
pad_2: array[68, byte]
positionSolverIterationCount*: uint8
velocitySolverIterationCount*: uint8
pad_3: array[50, byte]
maxDepenetrationVelocity*: float32
massInKgOverride*: float32
pad_4: array[8, byte]
linearDamping*: float32
angularDamping*: float32
pad_5: array[24, byte]
cOMNudge*: FVector
massScale*: float32
pad_6: array[4, byte]
inertiaTensorScale*: FVector
pad_7: array[16, byte]
walkableSlopeOverride*: FWalkableSlopeOverride
physMaterialOverride*: UPhysicalMaterialPtr
maxAngularVelocity*: float32
customSleepThresholdMultiplier*: float32
stabilizationThresholdMultiplier*: float32
pad_8: array[76, byte]
FCollisionResponseContainer* {.exportcpp: "$1_".} = object
worldStatic*: ECollisionResponse
worldDynamic*: ECollisionResponse
pawn*: ECollisionResponse
visibility*: ECollisionResponse
camera*: ECollisionResponse
physicsBody*: ECollisionResponse
vehicle*: ECollisionResponse
destructible*: ECollisionResponse
engineTraceChannel1*: ECollisionResponse
engineTraceChannel2*: ECollisionResponse
engineTraceChannel3*: ECollisionResponse
engineTraceChannel4*: ECollisionResponse
engineTraceChannel5*: ECollisionResponse
engineTraceChannel6*: ECollisionResponse
gameTraceChannel1*: ECollisionResponse
gameTraceChannel2*: ECollisionResponse
gameTraceChannel3*: ECollisionResponse
gameTraceChannel4*: ECollisionResponse
gameTraceChannel5*: ECollisionResponse
gameTraceChannel6*: ECollisionResponse
gameTraceChannel7*: ECollisionResponse
gameTraceChannel8*: ECollisionResponse
gameTraceChannel9*: ECollisionResponse
gameTraceChannel10*: ECollisionResponse
gameTraceChannel11*: ECollisionResponse
gameTraceChannel12*: ECollisionResponse
gameTraceChannel13*: ECollisionResponse
gameTraceChannel14*: ECollisionResponse
gameTraceChannel15*: ECollisionResponse
gameTraceChannel16*: ECollisionResponse
gameTraceChannel17*: ECollisionResponse
gameTraceChannel18*: ECollisionResponse
FLightingChannels* {.exportcpp: "$1_".} = object
bChannel0*: bool
bChannel1*: bool
bChannel2*: bool
FPostProcessSettings* {.exportcpp: "$1_".} = object
bOverride_TemperatureType*: bool
bOverride_WhiteTemp*: bool
bOverride_WhiteTint*: bool
bOverride_ColorSaturation*: bool
bOverride_ColorContrast*: bool
bOverride_ColorGamma*: bool
bOverride_ColorGain*: bool
bOverride_ColorOffset*: bool
bOverride_ColorSaturationShadows*: bool
bOverride_ColorContrastShadows*: bool
bOverride_ColorGammaShadows*: bool
bOverride_ColorGainShadows*: bool
bOverride_ColorOffsetShadows*: bool
bOverride_ColorSaturationMidtones*: bool
bOverride_ColorContrastMidtones*: bool
bOverride_ColorGammaMidtones*: bool
bOverride_ColorGainMidtones*: bool
bOverride_ColorOffsetMidtones*: bool
bOverride_ColorSaturationHighlights*: bool
bOverride_ColorContrastHighlights*: bool
bOverride_ColorGammaHighlights*: bool
bOverride_ColorGainHighlights*: bool
bOverride_ColorOffsetHighlights*: bool
bOverride_ColorCorrectionShadowsMax*: bool
bOverride_ColorCorrectionHighlightsMin*: bool
bOverride_ColorCorrectionHighlightsMax*: bool
bOverride_BlueCorrection*: bool
bOverride_ExpandGamut*: bool
bOverride_ToneCurveAmount*: bool
bOverride_FilmSlope*: bool
bOverride_FilmToe*: bool
bOverride_FilmShoulder*: bool
bOverride_FilmBlackClip*: bool
bOverride_FilmWhiteClip*: bool
bOverride_SceneColorTint*: bool
bOverride_SceneFringeIntensity*: bool
bOverride_ChromaticAberrationStartOffset*: bool
bOverride_AmbientCubemapTint*: bool
bOverride_AmbientCubemapIntensity*: bool
bOverride_BloomMethod*: bool
bOverride_BloomIntensity*: bool
bOverride_BloomThreshold*: bool
bOverride_Bloom1Tint*: bool
bOverride_Bloom1Size*: bool
bOverride_Bloom2Size*: bool
bOverride_Bloom2Tint*: bool
bOverride_Bloom3Tint*: bool
bOverride_Bloom3Size*: bool
bOverride_Bloom4Tint*: bool
bOverride_Bloom4Size*: bool
bOverride_Bloom5Tint*: bool
bOverride_Bloom5Size*: bool
bOverride_Bloom6Tint*: bool
bOverride_Bloom6Size*: bool
bOverride_BloomSizeScale*: bool
bOverride_BloomConvolutionTexture*: bool
bOverride_BloomConvolutionScatterDispersion*: bool
bOverride_BloomConvolutionSize*: bool
bOverride_BloomConvolutionCenterUV*: bool
bOverride_BloomConvolutionPreFilterMin*: bool
bOverride_BloomConvolutionPreFilterMax*: bool
bOverride_BloomConvolutionPreFilterMult*: bool
bOverride_BloomConvolutionBufferScale*: bool
bOverride_BloomDirtMaskIntensity*: bool
bOverride_BloomDirtMaskTint*: bool
bOverride_BloomDirtMask*: bool
bOverride_CameraShutterSpeed*: bool
bOverride_CameraISO*: bool
bOverride_AutoExposureMethod*: bool
bOverride_AutoExposureLowPercent*: bool
bOverride_AutoExposureHighPercent*: bool
bOverride_AutoExposureMinBrightness*: bool
bOverride_AutoExposureMaxBrightness*: bool
bOverride_AutoExposureSpeedUp*: bool
bOverride_AutoExposureSpeedDown*: bool
bOverride_AutoExposureBias*: bool
bOverride_AutoExposureBiasCurve*: bool
bOverride_AutoExposureMeterMask*: bool
bOverride_AutoExposureApplyPhysicalCameraExposure*: bool
bOverride_HistogramLogMin*: bool
bOverride_HistogramLogMax*: bool
bOverride_LocalExposureHighlightContrastScale*: bool
bOverride_LocalExposureShadowContrastScale*: bool
bOverride_LocalExposureDetailStrength*: bool
bOverride_LocalExposureBlurredLuminanceBlend*: bool
bOverride_LocalExposureBlurredLuminanceKernelSizePercent*: bool
bOverride_LocalExposureMiddleGreyBias*: bool
bOverride_LensFlareIntensity*: bool
bOverride_LensFlareTint*: bool
bOverride_LensFlareTints*: bool
bOverride_LensFlareBokehSize*: bool
bOverride_LensFlareBokehShape*: bool
bOverride_LensFlareThreshold*: bool
bOverride_VignetteIntensity*: bool
bOverride_FilmGrainIntensity*: bool
bOverride_FilmGrainIntensityShadows*: bool
bOverride_FilmGrainIntensityMidtones*: bool
bOverride_FilmGrainIntensityHighlights*: bool
bOverride_FilmGrainShadowsMax*: bool
bOverride_FilmGrainHighlightsMin*: bool
bOverride_FilmGrainHighlightsMax*: bool
bOverride_FilmGrainTexelSize*: bool
bOverride_FilmGrainTexture*: bool
bOverride_AmbientOcclusionIntensity*: bool
bOverride_AmbientOcclusionStaticFraction*: bool
bOverride_AmbientOcclusionRadius*: bool
bOverride_AmbientOcclusionFadeDistance*: bool
bOverride_AmbientOcclusionFadeRadius*: bool
bOverride_AmbientOcclusionRadiusInWS*: bool
bOverride_AmbientOcclusionPower*: bool
bOverride_AmbientOcclusionBias*: bool
bOverride_AmbientOcclusionQuality*: bool
bOverride_AmbientOcclusionMipBlend*: bool
bOverride_AmbientOcclusionMipScale*: bool
bOverride_AmbientOcclusionMipThreshold*: bool
bOverride_AmbientOcclusionTemporalBlendWeight*: bool
bOverride_RayTracingAO*: bool
bOverride_RayTracingAOSamplesPerPixel*: bool
bOverride_RayTracingAOIntensity*: bool
bOverride_RayTracingAORadius*: bool
bOverride_IndirectLightingColor*: bool
bOverride_IndirectLightingIntensity*: bool
bOverride_ColorGradingIntensity*: bool
bOverride_ColorGradingLUT*: bool
bOverride_DepthOfFieldFocalDistance*: bool
bOverride_DepthOfFieldFstop*: bool
bOverride_DepthOfFieldMinFstop*: bool
bOverride_DepthOfFieldBladeCount*: bool
bOverride_DepthOfFieldSensorWidth*: bool
bOverride_DepthOfFieldSqueezeFactor*: bool
bOverride_DepthOfFieldDepthBlurRadius*: bool
bOverride_DepthOfFieldDepthBlurAmount*: bool
bOverride_DepthOfFieldFocalRegion*: bool
bOverride_DepthOfFieldNearTransitionRegion*: bool
bOverride_DepthOfFieldFarTransitionRegion*: bool
bOverride_DepthOfFieldScale*: bool
bOverride_DepthOfFieldNearBlurSize*: bool
bOverride_DepthOfFieldFarBlurSize*: bool
bOverride_MobileHQGaussian*: bool
bOverride_DepthOfFieldOcclusion*: bool
bOverride_DepthOfFieldSkyFocusDistance*: bool
bOverride_DepthOfFieldVignetteSize*: bool
bOverride_MotionBlurAmount*: bool
bOverride_MotionBlurMax*: bool
bOverride_MotionBlurTargetFPS*: bool
bOverride_MotionBlurPerObjectSize*: bool
bOverride_ReflectionMethod*: bool
bOverride_LumenReflectionQuality*: bool
bOverride_ScreenSpaceReflectionIntensity*: bool
bOverride_ScreenSpaceReflectionQuality*: bool
bOverride_ScreenSpaceReflectionMaxRoughness*: bool
bOverride_ScreenSpaceReflectionRoughnessScale*: bool
bOverride_RayTracingReflectionsMaxRoughness*: bool
bOverride_RayTracingReflectionsMaxBounces*: bool
bOverride_RayTracingReflectionsSamplesPerPixel*: bool
bOverride_RayTracingReflectionsShadows*: bool
bOverride_RayTracingReflectionsTranslucency*: bool
bOverride_TranslucencyType*: bool
bOverride_RayTracingTranslucencyMaxRoughness*: bool
bOverride_RayTracingTranslucencyRefractionRays*: bool
bOverride_RayTracingTranslucencySamplesPerPixel*: bool
bOverride_RayTracingTranslucencyShadows*: bool
bOverride_RayTracingTranslucencyRefraction*: bool
bOverride_DynamicGlobalIlluminationMethod*: bool
bOverride_LumenSceneLightingQuality*: bool
bOverride_LumenSceneDetail*: bool
bOverride_LumenSceneViewDistance*: bool
bOverride_LumenSceneLightingUpdateSpeed*: bool
bOverride_LumenFinalGatherQuality*: bool
bOverride_LumenFinalGatherLightingUpdateSpeed*: bool
bOverride_LumenMaxTraceDistance*: bool
bOverride_LumenDiffuseColorBoost*: bool
bOverride_LumenSkylightLeaking*: bool
bOverride_LumenFullSkylightLeakingDistance*: bool
bOverride_LumenRayLightingMode*: bool
bOverride_LumenFrontLayerTranslucencyReflections*: bool
bOverride_LumenSurfaceCacheResolution*: bool
bOverride_RayTracingGI*: bool
bOverride_RayTracingGIMaxBounces*: bool
bOverride_RayTracingGISamplesPerPixel*: bool
bOverride_PathTracingMaxBounces*: bool
bOverride_PathTracingSamplesPerPixel*: bool
bOverride_PathTracingFilterWidth*: bool
bOverride_PathTracingEnableEmissive*: bool
bOverride_PathTracingMaxPathExposure*: bool
bOverride_PathTracingEnableReferenceDOF*: bool
bOverride_PathTracingEnableReferenceAtmosphere*: bool
bOverride_PathTracingEnableDenoiser*: bool
bMobileHQGaussian*: bool
bloomMethod*: EBloomMethod
autoExposureMethod*: EAutoExposureMethod
temperatureType*: ETemperatureMethod
whiteTemp*: float32
whiteTint*: float32
colorSaturation*: FVector4
colorContrast*: FVector4
colorGamma*: FVector4
colorGain*: FVector4
colorOffset*: FVector4
colorSaturationShadows*: FVector4
colorContrastShadows*: FVector4
colorGammaShadows*: FVector4
colorGainShadows*: FVector4
colorOffsetShadows*: FVector4
colorSaturationMidtones*: FVector4
colorContrastMidtones*: FVector4
colorGammaMidtones*: FVector4
colorGainMidtones*: FVector4
colorOffsetMidtones*: FVector4
colorSaturationHighlights*: FVector4
colorContrastHighlights*: FVector4
colorGammaHighlights*: FVector4
colorGainHighlights*: FVector4
colorOffsetHighlights*: FVector4
colorCorrectionHighlightsMin*: float32
colorCorrectionHighlightsMax*: float32
colorCorrectionShadowsMax*: float32
blueCorrection*: float32
expandGamut*: float32
toneCurveAmount*: float32
filmSlope*: float32
filmToe*: float32
filmShoulder*: float32
filmBlackClip*: float32
filmWhiteClip*: float32
sceneColorTint*: FLinearColor
sceneFringeIntensity*: float32
chromaticAberrationStartOffset*: float32
bloomIntensity*: float32
bloomThreshold*: float32
bloomSizeScale*: float32
bloom1Size*: float32
bloom2Size*: float32
bloom3Size*: float32
bloom4Size*: float32
bloom5Size*: float32
bloom6Size*: float32
bloom1Tint*: FLinearColor
bloom2Tint*: FLinearColor
bloom3Tint*: FLinearColor
bloom4Tint*: FLinearColor
bloom5Tint*: FLinearColor
bloom6Tint*: FLinearColor
bloomConvolutionScatterDispersion*: float32
bloomConvolutionSize*: float32
bloomConvolutionTexture*: UTexture2DPtr
bloomConvolutionCenterUV*: FVector2D
bloomConvolutionPreFilterMin*: float32
bloomConvolutionPreFilterMax*: float32
bloomConvolutionPreFilterMult*: float32
bloomConvolutionBufferScale*: float32
bloomDirtMask*: UTexturePtr
bloomDirtMaskIntensity*: float32
bloomDirtMaskTint*: FLinearColor
dynamicGlobalIlluminationMethod*: EDynamicGlobalIlluminationMethod
indirectLightingColor*: FLinearColor
indirectLightingIntensity*: float32
lumenSceneLightingQuality*: float32
lumenSceneDetail*: float32
lumenSceneViewDistance*: float32
lumenSceneLightingUpdateSpeed*: float32
lumenFinalGatherQuality*: float32
lumenFinalGatherLightingUpdateSpeed*: float32
lumenMaxTraceDistance*: float32
lumenDiffuseColorBoost*: float32
lumenSkylightLeaking*: float32
lumenFullSkylightLeakingDistance*: float32
lumenSurfaceCacheResolution*: float32
rayTracingGIType*: ERayTracingGlobalIlluminationType
rayTracingGIMaxBounces*: int32
rayTracingGISamplesPerPixel*: int32
reflectionMethod*: EReflectionMethod
lumenReflectionQuality*: float32
lumenRayLightingMode*: ELumenRayLightingModeOverride
lumenFrontLayerTranslucencyReflections*: uint8
screenSpaceReflectionIntensity*: float32
screenSpaceReflectionQuality*: float32
screenSpaceReflectionMaxRoughness*: float32
rayTracingReflectionsMaxRoughness*: float32
rayTracingReflectionsMaxBounces*: int32
rayTracingReflectionsSamplesPerPixel*: int32
rayTracingReflectionsShadows*: EReflectedAndRefractedRayTracedShadows
rayTracingReflectionsTranslucency*: uint8
ambientCubemapTint*: FLinearColor
ambientCubemapIntensity*: float32
ambientCubemap*: UTextureCubePtr
cameraShutterSpeed*: float32
cameraISO*: float32
depthOfFieldFstop*: float32
depthOfFieldMinFstop*: float32
depthOfFieldBladeCount*: int32
autoExposureBias*: float32
autoExposureApplyPhysicalCameraExposure*: uint8
autoExposureBiasCurve*: UCurveFloatPtr
autoExposureMeterMask*: UTexturePtr
autoExposureLowPercent*: float32
autoExposureHighPercent*: float32
autoExposureMinBrightness*: float32
autoExposureMaxBrightness*: float32
autoExposureSpeedUp*: float32
autoExposureSpeedDown*: float32
histogramLogMin*: float32
histogramLogMax*: float32
localExposureHighlightContrastScale*: float32
localExposureShadowContrastScale*: float32
localExposureDetailStrength*: float32
localExposureBlurredLuminanceBlend*: float32
localExposureBlurredLuminanceKernelSizePercent*: float32
localExposureMiddleGreyBias*: float32
lensFlareIntensity*: float32
lensFlareTint*: FLinearColor
lensFlareBokehSize*: float32
lensFlareThreshold*: float32
lensFlareBokehShape*: UTexturePtr
pad_0: array[56, byte]
vignetteIntensity*: float32
pad_1: array[8, byte]
filmGrainIntensity*: float32
filmGrainIntensityShadows*: float32
filmGrainIntensityMidtones*: float32
filmGrainIntensityHighlights*: float32
filmGrainShadowsMax*: float32
filmGrainHighlightsMin*: float32
filmGrainHighlightsMax*: float32
filmGrainTexelSize*: float32
pad_2: array[4, byte]
filmGrainTexture*: UTexture2DPtr
ambientOcclusionIntensity*: float32
ambientOcclusionStaticFraction*: float32
ambientOcclusionRadius*: float32
ambientOcclusionRadiusInWS*: uint8
pad_3: array[3, byte]
ambientOcclusionFadeDistance*: float32
ambientOcclusionFadeRadius*: float32
pad_4: array[4, byte]
ambientOcclusionPower*: float32
ambientOcclusionBias*: float32
ambientOcclusionQuality*: float32
ambientOcclusionMipBlend*: float32
ambientOcclusionMipScale*: float32
ambientOcclusionMipThreshold*: float32
ambientOcclusionTemporalBlendWeight*: float32
rayTracingAO*: uint8
pad_5: array[3, byte]
rayTracingAOSamplesPerPixel*: int32
rayTracingAOIntensity*: float32
rayTracingAORadius*: float32
colorGradingIntensity*: float32
pad_6: array[4, byte]
colorGradingLUT*: UTexturePtr
depthOfFieldSensorWidth*: float32
depthOfFieldSqueezeFactor*: float32
depthOfFieldFocalDistance*: float32
depthOfFieldDepthBlurAmount*: float32
depthOfFieldDepthBlurRadius*: float32
depthOfFieldFocalRegion*: float32
depthOfFieldNearTransitionRegion*: float32
depthOfFieldFarTransitionRegion*: float32
depthOfFieldScale*: float32
depthOfFieldNearBlurSize*: float32
depthOfFieldFarBlurSize*: float32
depthOfFieldOcclusion*: float32
depthOfFieldSkyFocusDistance*: float32
depthOfFieldVignetteSize*: float32
motionBlurAmount*: float32
motionBlurMax*: float32
motionBlurTargetFPS*: int32
motionBlurPerObjectSize*: float32
pad_7: array[52, byte]
translucencyType*: ETranslucencyType
pad_8: array[3, byte]
rayTracingTranslucencyMaxRoughness*: float32
rayTracingTranslucencyRefractionRays*: int32
rayTracingTranslucencySamplesPerPixel*: int32
rayTracingTranslucencyShadows*: EReflectedAndRefractedRayTracedShadows
rayTracingTranslucencyRefraction*: uint8
pad_9: array[2, byte]
pathTracingMaxBounces*: int32
pathTracingSamplesPerPixel*: int32
pathTracingFilterWidth*: float32
pathTracingEnableEmissive*: uint8
pad_10: array[3, byte]
pathTracingMaxPathExposure*: float32
pathTracingEnableReferenceDOF*: uint8
pathTracingEnableReferenceAtmosphere*: uint8
pathTracingEnableDenoiser*: uint8
pad_11: array[17, byte]
weightedBlendables*: FWeightedBlendables
pad_12: array[24, byte]
FWeightedBlendables* {.exportcpp: "$1_".} = object
array*: TArray[FWeightedBlendable]
FWeightedBlendable* {.exportcpp: "$1_".} = object
weight*: float32
pad_0: array[4, byte]
`object`*: UObjectPtr
FEdGraphPinType* {.exportcpp: "$1_".} = object
pad_0: array[112, byte]
FPoseLinkBase* {.exportcpp: "$1_".} = object
pad_0: array[24, byte]
FPoseLink* {.exportcpp: "$1_".} = object
pad_0: array[24, byte]
FAnimNode_Root* {.exportcpp: "$1_".} = object
pad_0: array[136, byte]
Result*: FPoseLink
pad_1: array[24, byte]
FInputScaleBiasClamp* {.exportcpp: "$1_".} = object
bMapRange*: bool
bClampResult*: bool
bInterpResult*: bool
pad_0: array[1, byte]
inRange*: FInputRange
outRange*: FInputRange
scale*: float32
bias*: float32
clampMin*: float32
clampMax*: float32
interpSpeedIncreasing*: float32
interpSpeedDecreasing*: float32
pad_1: array[4, byte]
FInputRange* {.exportcpp: "$1_".} = object
Min*: float32
Max*: float32
FInputAlphaBoolBlend* {.exportcpp: "$1_".} = object
blendInTime*: float32
blendOutTime*: float32
blendOption*: EAlphaBlendOption
pad_0: array[7, byte]
customCurve*: UCurveFloatPtr
pad_1: array[48, byte]
FAlphaBlend* {.exportcpp: "$1_".} = object
pad_0: array[48, byte]
FInputScaleBias* {.exportcpp: "$1_".} = object
scale*: float32
bias*: float32
FComponentSpacePoseLink* {.exportcpp: "$1_".} = object
pad_0: array[24, byte]
FAnimNodeReference* {.exportcpp: "$1_".} = object
pad_0: array[16, byte]
FRuntimeFloatCurve* {.exportcpp: "$1_".} = object
pad_0: array[136, byte]
FRichCurveKey* {.exportcpp: "$1_".} = object
pad_0: array[4, byte]
time*: float32
value*: float32
pad_1: array[16, byte]
FAnimNode_AssetPlayerRelevancyBase* {.exportcpp: "$1_".} = object
pad_0: array[136, byte]
FAnimNode_AssetPlayerBase* {.exportcpp: "$1_".} = object
pad_0: array[160, byte]
blendWeight*: float32
internalTimeAccumulator*: float32
pad_1: array[16, byte]
FPerBoneBlendWeight* {.exportcpp: "$1_".} = object
pad_0: array[8, byte]
FPoseSnapshot* {.exportcpp: "$1_".} = object
localTransforms*: TArray[FTransform]
boneNames*: TArray[FName]
skeletalMeshName*: FName
snapshotName*: FName
bIsValid*: bool
pad_0: array[7, byte]
FActorDataLayer* {.exportcpp: "$1_".} = object
name*: FName
FMaterialParameterInfo* {.exportcpp: "$1_".} = object
name*: FName
association*: EMaterialParameterAssociation
pad_0: array[3, byte]
index*: int32
FNamedFloat* {.exportcpp: "$1_".} = object
value*: float32
name*: FName
FNamedVector* {.exportcpp: "$1_".} = object
value*: FVector
name*: FName
pad_0: array[4, byte]
FNamedColor* {.exportcpp: "$1_".} = object
value*: FColor
name*: FName
FNamedTransform* {.exportcpp: "$1_".} = object
value*: FTransform
name*: FName
pad_0: array[4, byte]
FLocalSpacePose* {.exportcpp: "$1_".} = object
transforms*: TArray[FTransform]
names*: TArray[FName]
FComponentSpacePose* {.exportcpp: "$1_".} = object
transforms*: TArray[FTransform]
names*: TArray[FName]
FAnimCurveBase* {.exportcpp: "$1_".} = object
pad_0: array[48, byte]
FFloatCurve* {.exportcpp: "$1_".} = object
pad_0: array[176, byte]
FTransformCurve* {.exportcpp: "$1_".} = object
pad_0: array[1344, byte]
FCachedFloatCurve* {.exportcpp: "$1_".} = object
curveName*: FName
pad_0: array[16, byte]
FEmptyPayload* {.exportcpp: "$1_".} = object
pad_0: array[1, byte]
FBracketPayload* {.exportcpp: "$1_".} = object
description*: FString
FAnimationTrackPayload* {.exportcpp: "$1_".} = object
name*: FName
FAnimationTrackAddedPayload* {.exportcpp: "$1_".} = object
pad_0: array[12, byte]
trackIndex*: int32
FSequenceLengthChangedPayload* {.exportcpp: "$1_".} = object
previousLength*: float32
t0*: float32
t1*: float32
FFrameRateChangedPayload* {.exportcpp: "$1_".} = object
previousFrameRate*: FFrameRate
FCurvePayload* {.exportcpp: "$1_".} = object
identifier*: FAnimationCurveIdentifier
FAnimationCurveIdentifier* {.exportcpp: "$1_".} = object
pad_0: array[20, byte]
FCurveScaledPayload* {.exportcpp: "$1_".} = object
pad_0: array[20, byte]
factor*: float32
origin*: float32
FCurveRenamedPayload* {.exportcpp: "$1_".} = object
pad_0: array[20, byte]
newIdentifier*: FAnimationCurveIdentifier
FCurveFlagsChangedPayload* {.exportcpp: "$1_".} = object
pad_0: array[20, byte]
oldFlags*: int32
FAttributePayload* {.exportcpp: "$1_".} = object
identifier*: FAnimationAttributeIdentifier
FAnimationAttributeIdentifier* {.exportcpp: "$1_".} = object
name*: FName
boneName*: FName
boneIndex*: int32
pad_0: array[4, byte]
scriptStruct*: UScriptStructPtr
scriptStructPath*: FSoftObjectPath
FAnimNodeConstantData* {.exportcpp: "$1_".} = object
pad_0: array[24, byte]
FPerBoneBlendWeights* {.exportcpp: "$1_".} = object
pad_0: array[16, byte]
FAnimNotifyEvent* {.exportcpp: "$1_".} = object
pad_0: array[60, byte]
triggerWeightThreshold*: float32
notifyName*: FName
pad_1: array[4, byte]
notify*: UAnimNotifyPtr
notifyStateClass*: UAnimNotifyStatePtr
pad_2: array[57, byte]
montageTickType*: EMontageNotifyTickType
pad_3: array[2, byte]
notifyTriggerChance*: float32
notifyFilterType*: ENotifyFilterType
pad_4: array[3, byte]
notifyFilterLOD*: int32
bTriggerOnDedicatedServer*: bool
bTriggerOnFollower*: bool
pad_5: array[54, byte]
FAnimSyncMarker* {.exportcpp: "$1_".} = object
markerName*: FName
time*: float32
pad_0: array[20, byte]
FRawAnimSequenceTrack* {.exportcpp: "$1_".} = object
pad_0: array[48, byte]
FFloatAnimationAttribute* {.exportcpp: "$1_".} = object
value*: float32
FIntegerAnimationAttribute* {.exportcpp: "$1_".} = object
value*: int32
FStringAnimationAttribute* {.exportcpp: "$1_".} = object
value*: FString
FTransformAnimationAttribute* {.exportcpp: "$1_".} = object
value*: FTransform
FVectorAnimationAttribute* {.exportcpp: "$1_".} = object
value*: FVector
FQuaternionAnimationAttribute* {.exportcpp: "$1_".} = object
value*: FQuat
FMinimalViewInfo* {.exportcpp: "$1_".} = object
location*: FVector
rotation*: FRotator
fOV*: float32
pad_0: array[4, byte]
orthoWidth*: float32
orthoNearClipPlane*: float32
orthoFarClipPlane*: float32
perspectiveNearClipPlane*: float32
aspectRatio*: float32
bConstrainAspectRatio*: bool
bUseFieldOfViewForLOD*: bool
pad_1: array[2, byte]
projectionMode*: ECameraProjectionMode
pad_2: array[3, byte]
postProcessBlendWeight*: float32
pad_3: array[8, byte]
postProcessSettings*: FPostProcessSettings
offCenterProjectionOffset*: FVector2D
pad_4: array[112, byte]
FMeshUVChannelInfo* {.exportcpp: "$1_".} = object
pad_0: array[20, byte]
FFractureEffect* {.exportcpp: "$1_".} = object
particleSystem*: UParticleSystemPtr
sound*: USoundBasePtr
FBasedPosition* {.exportcpp: "$1_".} = object
base*: AActorPtr
position*: FVector
pad_0: array[72, byte]
FPOV* {.exportcpp: "$1_".} = object
location*: FVector
rotation*: FRotator
fOV*: float32
pad_0: array[4, byte]
FMeshBuildSettings* {.exportcpp: "$1_".} = object
bUseMikkTSpace*: bool
bRecomputeNormals*: bool
bRecomputeTangents*: bool
bComputeWeightedNormals*: bool
bRemoveDegenerates*: bool
bBuildReversedIndexBuffer*: bool
bUseHighPrecisionTangentBasis*: bool
bUseFullPrecisionUVs*: bool
bUseBackwardsCompatibleF16TruncUVs*: bool
bGenerateLightmapUVs*: bool
bGenerateDistanceFieldAsIfTwoSided*: bool
bSupportFaceRemap*: bool
minLightmapResolution*: int32
srcLightmapIndex*: int32
dstLightmapIndex*: int32
buildScale3D*: FVector
distanceFieldResolutionScale*: float32
pad_0: array[4, byte]
distanceFieldReplacementMesh*: UStaticMeshPtr
maxLumenMeshCards*: int32
pad_1: array[4, byte]
FSkeletalMeshBuildSettings* {.exportcpp: "$1_".} = object
bRecomputeNormals*: bool
bRecomputeTangents*: bool
bUseMikkTSpace*: bool
bComputeWeightedNormals*: bool
bRemoveDegenerates*: bool
bUseHighPrecisionTangentBasis*: bool
bUseFullPrecisionUVs*: bool
bUseBackwardsCompatibleF16TruncUVs*: bool
thresholdPosition*: float32
thresholdTangentNormal*: float32
thresholdUV*: float32
morphThresholdPosition*: float32
FMeshNaniteSettings* {.exportcpp: "$1_".} = object
bEnabled*: bool
bPreserveArea*: bool
pad_0: array[2, byte]
positionPrecision*: int32
pad_1: array[4, byte]
keepPercentTriangles*: float32
trimRelativeError*: float32
fallbackPercentTriangles*: float32
fallbackRelativeError*: float32
FBaseComponentReference* {.exportcpp: "$1_".} = object
componentProperty*: FName
pad_0: array[28, byte]
FComponentReference* {.exportcpp: "$1_".} = object
pad_0: array[40, byte]
otherActor*: TWeakObjectPtr[AActor]
FSoftComponentReference* {.exportcpp: "$1_".} = object
pad_0: array[40, byte]
otherActor*: TSoftObjectPtr[AActor]
FCollectionReference* {.exportcpp: "$1_".} = object
collectionName*: FName
FDepthFieldGlowInfo* {.exportcpp: "$1_".} = object
bEnableGlow*: bool
pad_0: array[3, byte]
glowColor*: FLinearColor
pad_1: array[4, byte]
glowOuterRadius*: FVector2D
glowInnerRadius*: FVector2D
FFontRenderInfo* {.exportcpp: "$1_".} = object
bClipText*: bool
bEnableShadow*: bool
pad_0: array[6, byte]
glowInfo*: FDepthFieldGlowInfo
FCanvasUVTri* {.exportcpp: "$1_".} = object
v0_Pos*: FVector2D
v0_UV*: FVector2D
v0_Color*: FLinearColor
v1_Pos*: FVector2D
v1_UV*: FVector2D
v1_Color*: FLinearColor
v2_Pos*: FVector2D
v2_UV*: FVector2D
v2_Color*: FLinearColor
FExponentialHeightFogData* {.exportcpp: "$1_".} = object
fogDensity*: float32
fogHeightFalloff*: float32
fogHeightOffset*: float32
FBaseAttenuationSettings* {.exportcpp: "$1_".} = object
pad_0: array[8, byte]
distanceAlgorithm*: EAttenuationDistanceModel
attenuationShape*: EAttenuationShape
falloffMode*: ENaturalSoundFalloffMode
pad_1: array[1, byte]
dBAttenuationAtMax*: float32
attenuationShapeExtents*: FVector
coneOffset*: float32
falloffDistance*: float32
coneSphereRadius*: float32
coneSphereFalloffDistance*: float32
customAttenuationCurve*: FRuntimeFloatCurve
FForceFeedbackAttenuationSettings* {.exportcpp: "$1_".} = object
pad_0: array[192, byte]
FPredictProjectilePathParams* {.exportcpp: "$1_".} = object
startLocation*: FVector
launchVelocity*: FVector
bTraceWithCollision*: bool
pad_0: array[3, byte]
projectileRadius*: float32
maxSimTime*: float32
bTraceWithChannel*: bool
traceChannel*: ECollisionChannel
pad_1: array[2, byte]
objectTypes*: TArray[EObjectTypeQuery]
actorsToIgnore*: TArray[AActorPtr]
simFrequency*: float32
overrideGravityZ*: float32
drawDebugType*: EDrawDebugTrace
pad_2: array[3, byte]
drawDebugTime*: float32
bTraceComplex*: bool
pad_3: array[7, byte]
FPredictProjectilePathPointData* {.exportcpp: "$1_".} = object
location*: FVector
velocity*: FVector
time*: float32
pad_0: array[4, byte]
FPredictProjectilePathResult* {.exportcpp: "$1_".} = object
pathData*: TArray[FPredictProjectilePathPointData]
lastTraceDestination*: FPredictProjectilePathPointData
hitResult*: FHitResult
FMaterialProxySettings* {.exportcpp: "$1_".} = object
textureSizingType*: ETextureSizingType
pad_0: array[11, byte]
targetTexelDensityPerMeter*: float32
meshMaxScreenSizePercent*: float32
meshMinDrawDistance*: float32
gutterSpace*: float32
metallicConstant*: float32
roughnessConstant*: float32
anisotropyConstant*: float32
specularConstant*: float32
opacityConstant*: float32
opacityMaskConstant*: float32
ambientOcclusionConstant*: float32
pad_1: array[1, byte]
blendMode*: EBlendMode
bAllowTwoSidedMaterial*: bool
bNormalMap*: bool
bTangentMap*: bool
bMetallicMap*: bool
bRoughnessMap*: bool
bAnisotropyMap*: bool
bSpecularMap*: bool
bEmissiveMap*: bool
bOpacityMap*: bool
bOpacityMaskMap*: bool
bAmbientOcclusionMap*: bool
diffuseTextureSize*: FIntPoint
normalTextureSize*: FIntPoint
tangentTextureSize*: FIntPoint
metallicTextureSize*: FIntPoint
roughnessTextureSize*: FIntPoint
anisotropyTextureSize*: FIntPoint
specularTextureSize*: FIntPoint
emissiveTextureSize*: FIntPoint
opacityTextureSize*: FIntPoint
opacityMaskTextureSize*: FIntPoint
ambientOcclusionTextureSize*: FIntPoint
FMaterialOverrideNanite* {.exportcpp: "$1_".} = object
overrideMaterialRef*: TSoftObjectPtr[UMaterialInterface]
pad_0: array[16, byte]
FNavAvoidanceMask* {.exportcpp: "$1_".} = object
bGroup0*: bool
bGroup1*: bool
bGroup2*: bool
bGroup3*: bool
bGroup4*: bool
bGroup5*: bool
bGroup6*: bool
bGroup7*: bool
bGroup8*: bool
bGroup9*: bool
bGroup10*: bool
bGroup11*: bool
bGroup12*: bool
bGroup13*: bool
bGroup14*: bool
bGroup15*: bool
bGroup16*: bool
bGroup17*: bool
bGroup18*: bool
bGroup19*: bool
bGroup20*: bool
bGroup21*: bool
bGroup22*: bool
bGroup23*: bool
bGroup24*: bool
bGroup25*: bool
bGroup26*: bool
bGroup27*: bool
bGroup28*: bool
bGroup29*: bool
bGroup30*: bool
bGroup31*: bool
FNavigationLinkBase* {.exportcpp: "$1_".} = object
pad_0: array[48, byte]
direction*: ENavLinkDirection
pad_1: array[23, byte]
FNavigationLink* {.exportcpp: "$1_".} = object
pad_0: array[72, byte]
left*: FVector
right*: FVector
FParticleSysParam* {.exportcpp: "$1_".} = object
name*: FName
paramType*: EParticleSysParamType
pad_0: array[3, byte]
scalar*: float32
scalar_Low*: float32
vector*: FVector
vector_Low*: FVector
color*: FColor
pad_1: array[4, byte]
actor*: AActorPtr
material*: UMaterialInterfacePtr
pad_2: array[128, byte]
FFXSystemSpawnParameters* {.exportcpp: "$1_".} = object
pad_0: array[120, byte]
FTViewTarget* {.exportcpp: "$1_".} = object
target*: AActorPtr
pad_0: array[8, byte]
pOV*: FMinimalViewInfo
playerState*: APlayerStatePtr
pad_1: array[8, byte]
FViewTargetTransitionParams* {.exportcpp: "$1_".} = object
blendTime*: float32
blendFunction*: EViewTargetBlendFunction
pad_0: array[3, byte]
blendExp*: float32
bLockOutgoing*: bool
pad_1: array[3, byte]
FReverbSettings* {.exportcpp: "$1_".} = object
bApplyReverb*: bool
pad_0: array[7, byte]
reverbEffect*: UReverbEffectPtr
reverbPluginEffect*: USoundEffectSubmixPresetPtr
volume*: float32
fadeTime*: float32
FColorGradePerRangeSettings* {.exportcpp: "$1_".} = object
saturation*: FVector4
contrast*: FVector4
gamma*: FVector4
gain*: FVector4
offset*: FVector4
FColorGradingSettings* {.exportcpp: "$1_".} = object
global*: FColorGradePerRangeSettings
shadows*: FColorGradePerRangeSettings
midtones*: FColorGradePerRangeSettings
highlights*: FColorGradePerRangeSettings
shadowsMax*: float32
highlightsMin*: float32
highlightsMax*: float32
pad_0: array[4, byte]
FFilmStockSettings* {.exportcpp: "$1_".} = object
slope*: float32
toe*: float32
shoulder*: float32
blackClip*: float32
whiteClip*: float32
FGaussianSumBloomSettings* {.exportcpp: "$1_".} = object
intensity*: float32
threshold*: float32
sizeScale*: float32
filter1Size*: float32
filter2Size*: float32
filter3Size*: float32
filter4Size*: float32
filter5Size*: float32
filter6Size*: float32
filter1Tint*: FLinearColor
filter2Tint*: FLinearColor
filter3Tint*: FLinearColor
filter4Tint*: FLinearColor
filter5Tint*: FLinearColor
filter6Tint*: FLinearColor
FConvolutionBloomSettings* {.exportcpp: "$1_".} = object
texture*: UTexture2DPtr
scatterDispersion*: float32
size*: float32
centerUV*: FVector2D
preFilterMin*: float32
preFilterMax*: float32
preFilterMult*: float32
bufferScale*: float32
FLensBloomSettings* {.exportcpp: "$1_".} = object
gaussianSum*: FGaussianSumBloomSettings
pad_0: array[4, byte]
convolution*: FConvolutionBloomSettings
`method`*: EBloomMethod
pad_1: array[7, byte]
FLensImperfectionSettings* {.exportcpp: "$1_".} = object
dirtMask*: UTexturePtr
dirtMaskIntensity*: float32
dirtMaskTint*: FLinearColor
pad_0: array[4, byte]
FLensSettings* {.exportcpp: "$1_".} = object
bloom*: FLensBloomSettings
imperfections*: FLensImperfectionSettings
chromaticAberration*: float32
pad_0: array[4, byte]
FCameraExposureSettings* {.exportcpp: "$1_".} = object
`method`*: EAutoExposureMethod
pad_0: array[3, byte]
lowPercent*: float32
highPercent*: float32
minBrightness*: float32
maxBrightness*: float32
speedUp*: float32
speedDown*: float32
bias*: float32
biasCurve*: UCurveFloatPtr
meterMask*: UTexturePtr
histogramLogMin*: float32
histogramLogMax*: float32
calibrationConstant*: float32
applyPhysicalCameraExposure*: uint8
pad_1: array[3, byte]
FSceneViewExtensionIsActiveFunctor* {.exportcpp: "$1_".} = object
pad_0: array[96, byte]
FSkeletalMaterial* {.exportcpp: "$1_".} = object
materialInterface*: UMaterialInterfacePtr
materialSlotName*: FName
pad_0: array[16, byte]
uVChannelData*: FMeshUVChannelInfo
FSkelMeshSkinWeightInfo* {.exportcpp: "$1_".} = object
pad_0: array[60, byte]
FVertexOffsetUsage* {.exportcpp: "$1_".} = object
pad_0: array[4, byte]
FSoundAttenuationPluginSettings* {.exportcpp: "$1_".} = object
spatializationPluginSettingsArray*: TArray[
USpatializationPluginSourceSettingsBasePtr]
occlusionPluginSettingsArray*: TArray[UOcclusionPluginSourceSettingsBasePtr]
reverbPluginSettingsArray*: TArray[UReverbPluginSourceSettingsBasePtr]
sourceDataOverridePluginSettingsArray*: TArray[
USourceDataOverridePluginSourceSettingsBasePtr]
FAttenuationSubmixSendSettings* {.exportcpp: "$1_".} = object
submix*: USoundSubmixBasePtr
submixSendMethod*: ESubmixSendMethod
pad_0: array[3, byte]
submixSendLevelMin*: float32
submixSendLevelMax*: float32
submixSendDistanceMin*: float32
submixSendDistanceMax*: float32
manualSubmixSendLevel*: float32
customSubmixSendCurve*: FRuntimeFloatCurve
FSoundAttenuationSettings* {.exportcpp: "$1_".} = object
pad_0: array[192, byte]
bAttenuate*: bool
bSpatialize*: bool
bAttenuateWithLPF*: bool
bEnableListenerFocus*: bool
bEnableFocusInterpolation*: bool
bEnableOcclusion*: bool
bUseComplexCollisionForOcclusion*: bool
bEnableReverbSend*: bool
bEnablePriorityAttenuation*: bool
bApplyNormalizationToStereoSounds*: bool
bEnableLogFrequencyScaling*: bool
bEnableSubmixSends*: bool
bEnableSourceDataOverride*: bool
bEnableSendToAudioLink*: bool
spatializationAlgorithm*: ESoundSpatializationAlgorithm
pad_1: array[1, byte]
binauralRadius*: float32
pad_2: array[4, byte]
customLowpassAirAbsorptionCurve*: FRuntimeFloatCurve
customHighpassAirAbsorptionCurve*: FRuntimeFloatCurve
absorptionMethod*: EAirAbsorptionMethod
occlusionTraceChannel*: ECollisionChannel
reverbSendMethod*: EReverbSendMethod
priorityAttenuationMethod*: EPriorityAttenuationMethod
pad_3: array[4, byte]
omniRadius*: float32
stereoSpread*: float32
pad_4: array[16, byte]
lPFRadiusMin*: float32
lPFRadiusMax*: float32
lPFFrequencyAtMin*: float32
lPFFrequencyAtMax*: float32
hPFFrequencyAtMin*: float32
hPFFrequencyAtMax*: float32
focusAzimuth*: float32
nonFocusAzimuth*: float32
focusDistanceScale*: float32
nonFocusDistanceScale*: float32
focusPriorityScale*: float32
nonFocusPriorityScale*: float32
focusVolumeAttenuation*: float32
nonFocusVolumeAttenuation*: float32
focusAttackInterpSpeed*: float32
focusReleaseInterpSpeed*: float32
occlusionLowPassFilterFrequency*: float32
occlusionVolumeAttenuation*: float32
occlusionInterpolationTime*: float32
pad_5: array[20, byte]
reverbWetLevelMin*: float32
reverbWetLevelMax*: float32
reverbDistanceMin*: float32
reverbDistanceMax*: float32
manualReverbSendLevel*: float32
priorityAttenuationMin*: float32
priorityAttenuationMax*: float32
priorityAttenuationDistanceMin*: float32
priorityAttenuationDistanceMax*: float32
manualPriorityAttenuation*: float32
customReverbSendCurve*: FRuntimeFloatCurve
submixSendSettings*: TArray[FAttenuationSubmixSendSettings]
customPriorityAttenuationCurve*: FRuntimeFloatCurve
pluginSettings*: FSoundAttenuationPluginSettings
FSourceEffectChainEntry* {.exportcpp: "$1_".} = object
preset*: USoundEffectSourcePresetPtr
bBypass*: bool
pad_0: array[7, byte]
FSoundSourceBusSendInfo* {.exportcpp: "$1_".} = object
pad_0: array[28, byte]
minSendLevel*: float32
maxSendLevel*: float32
minSendDistance*: float32
maxSendDistance*: float32
pad_1: array[4, byte]
customSendLevelCurve*: FRuntimeFloatCurve
FSoundWaveSpectralData* {.exportcpp: "$1_".} = object
frequencyHz*: float32
magnitude*: float32
normalizedMagnitude*: float32
FSoundWaveSpectralDataPerSound* {.exportcpp: "$1_".} = object
spectralData*: TArray[FSoundWaveSpectralData]
playbackTime*: float32
pad_0: array[4, byte]
soundWave*: USoundWavePtr
FSoundWaveEnvelopeDataPerSound* {.exportcpp: "$1_".} = object
envelope*: float32
playbackTime*: float32
soundWave*: USoundWavePtr
FSoundWaveCuePoint* {.exportcpp: "$1_".} = object
cuePointID*: int32
pad_0: array[4, byte]
label*: FString
framePosition*: int32
frameLength*: int32
FStaticMaterial* {.exportcpp: "$1_".} = object
materialInterface*: UMaterialInterfacePtr
materialSlotName*: FName
pad_0: array[12, byte]
uVChannelData*: FMeshUVChannelInfo
pad_1: array[4, byte]
FEquirectProps* {.exportcpp: "$1_".} = object
leftUVRect*: FBox2D
rightUVRect*: FBox2D
leftScale*: FVector2D
rightScale*: FVector2D
leftBias*: FVector2D
rightBias*: FVector2D
FTextureSourceColorSettings* {.exportcpp: "$1_".} = object
encodingOverride*: ETextureSourceEncoding
colorSpace*: ETextureColorSpace
pad_0: array[6, byte]
redChromaticityCoordinate*: FVector2D
greenChromaticityCoordinate*: FVector2D
blueChromaticityCoordinate*: FVector2D
whiteChromaticityCoordinate*: FVector2D
chromaticAdaptationMethod*: ETextureChromaticAdaptationMethod
pad_1: array[7, byte]
FStreamingSourceShape* {.exportcpp: "$1_".} = object
bUseGridLoadingRange*: bool
pad_0: array[3, byte]
radius*: float32
bIsSector*: bool
pad_1: array[3, byte]
sectorAngle*: float32
location*: FVector
rotation*: FRotator
FWorldPartitionStreamingQuerySource* {.exportcpp: "$1_".} = object
location*: FVector
radius*: float32
bUseGridLoadingRange*: bool
pad_0: array[3, byte]
dataLayers*: TArray[FName]
bDataLayersOnly*: bool
bSpatialQuery*: bool
pad_1: array[102, byte]
FLightmassWorldInfoSettings* {.exportcpp: "$1_".} = object
staticLightingLevelScale*: float32
numIndirectLightingBounces*: int32
numSkyLightingBounces*: int32
indirectLightingQuality*: float32
indirectLightingSmoothness*: float32
environmentColor*: FColor
environmentIntensity*: float32
pad_0: array[4, byte]
diffuseBoost*: float32
volumeLightingMethod*: EVolumeLightingMethod
bUseAmbientOcclusion*: bool
bGenerateAmbientOcclusionMaterialMask*: bool
bVisualizeMaterialDiffuse*: bool
bVisualizeAmbientOcclusion*: bool
bCompressLightmaps*: bool
volumetricLightmapDetailCellSize*: float32
volumetricLightmapMaximumBrickMemoryMb*: float32
volumetricLightmapSphericalHarmonicSmoothing*: float32
volumeLightSamplePlacementScale*: float32
directIlluminationOcclusionFraction*: float32
indirectIlluminationOcclusionFraction*: float32
occlusionExponent*: float32
fullyOccludedSamplesFraction*: float32
maxOcclusionDistance*: float32
FMeshApproximationSettings* {.exportcpp: "$1_".} = object
outputType*: EMeshApproximationType
pad_0: array[3, byte]
approximationAccuracy*: float32
clampVoxelDimension*: int32
bAttemptAutoThickening*: bool
pad_1: array[3, byte]
targetMinThicknessMultiplier*: float32
bIgnoreTinyParts*: bool
pad_2: array[3, byte]
tinyPartSizeMultiplier*: float32
baseCapping*: EMeshApproximationBaseCappingType
pad_3: array[3, byte]
windingThreshold*: float32
bFillGaps*: bool
pad_4: array[3, byte]
gapDistance*: float32
occlusionMethod*: EOccludedGeometryFilteringPolicy
bOccludeFromBottom*: bool
simplifyMethod*: EMeshApproximationSimplificationPolicy
pad_5: array[1, byte]
targetTriCount*: int32
trianglesPerM*: float32
geometricDeviation*: float32
groundClipping*: EMeshApproximationGroundPlaneClippingPolicy
pad_6: array[3, byte]
groundClippingZHeight*: float32
bEstimateHardNormals*: bool
pad_7: array[3, byte]
hardNormalAngle*: float32
uVGenerationMethod*: EMeshApproximationUVGenerationPolicy
pad_8: array[3, byte]
initialPatchCount*: int32
curvatureAlignment*: float32
mergingThreshold*: float32
maxAngleDeviation*: float32
bGenerateNaniteEnabledMesh*: bool
pad_9: array[3, byte]
naniteProxyTrianglePercent*: float32
bSupportRayTracing*: bool
bAllowDistanceField*: bool
pad_10: array[2, byte]
multiSamplingAA*: int32
renderCaptureResolution*: int32
materialSettings*: FMaterialProxySettings
captureFieldOfView*: float32
nearPlaneDist*: float32
bUseRenderLODMeshes*: bool
bEnableSimplifyPrePass*: bool
bEnableParallelBaking*: bool
bPrintDebugMessages*: bool
bEmitFullDebugMesh*: bool
pad_11: array[3, byte]
FMeshMergingSettings* {.exportcpp: "$1_".} = object
targetLightMapResolution*: int32
pad_0: array[8, byte]
materialSettings*: FMaterialProxySettings
pad_1: array[4, byte]
lODSelectionType*: EMeshLODSelectionType
pad_2: array[3, byte]
specificLOD*: int32
bGenerateLightMapUV*: bool
bComputedLightMapResolution*: bool
bPivotPointAtZero*: bool
bMergePhysicsData*: bool
bMergeMaterials*: bool
bCreateMergedMaterial*: bool
bBakeVertexDataToMesh*: bool
bUseVertexDataForBakingMaterial*: bool
bUseTextureBinning*: bool
bUseLandscapeCulling*: bool
bIncludeImposters*: bool
bSupportRayTracing*: bool
naniteSettings*: FMeshNaniteSettings
pad_3: array[16, byte]
FMeshProxySettings* {.exportcpp: "$1_".} = object
screenSize*: int32
voxelSize*: float32
materialSettings*: FMaterialProxySettings
pad_0: array[16, byte]
mergeDistance*: float32
unresolvedGeometryColor*: FColor
maxRayCastDist*: float32
hardAngleThreshold*: float32
lightMapResolution*: int32
normalCalculationMethod*: EProxyNormalComputationMethod
landscapeCullingPrecision*: ELandscapeCullingPrecision
bCalculateCorrectLODModel*: bool
bOverrideVoxelSize*: bool
bOverrideTransferDistance*: bool
bUseHardAngleThreshold*: bool
bComputeLightMapResolution*: bool
bRecalculateNormals*: bool
bUseLandscapeCulling*: bool
bSupportRayTracing*: bool
bAllowDistanceField*: bool
bReuseMeshLightmapUVs*: bool
bGroupIdenticalMeshesForBaking*: bool
bCreateCollision*: bool
bAllowVertexColors*: bool
bGenerateLightmapUVs*: bool
naniteSettings*: FMeshNaniteSettings
FAttributeCurve* {.exportcpp: "$1_".} = object
pad_0: array[184, byte]
FQuartzPulseOverrideStep* {.exportcpp: "$1_".} = object
numberOfPulses*: int32
pulseDuration*: EQuartzCommandQuantization
pad_0: array[3, byte]
FQuartzTimeSignature* {.exportcpp: "$1_".} = object
numBeats*: int32
beatType*: EQuartzTimeSignatureQuantization
pad_0: array[3, byte]
optionalPulseOverride*: TArray[FQuartzPulseOverrideStep]
FQuartzTransportTimeStamp* {.exportcpp: "$1_".} = object
bars*: int32
beat*: int32
beatFraction*: float32
seconds*: float32
FQuartzClockSettings* {.exportcpp: "$1_".} = object
timeSignature*: FQuartzTimeSignature
bIgnoreLevelChange*: bool
pad_0: array[7, byte]
FQuartzQuantizationBoundary* {.exportcpp: "$1_".} = object
quantization*: EQuartzCommandQuantization
pad_0: array[3, byte]
multiplier*: float32
countingReferencePoint*: EQuarztQuantizationReference
bFireOnClockStart*: bool
bCancelCommandIfClockIsNotRunning*: bool
bResetClockOnQueued*: bool
bResumeClockOnQueued*: bool
pad_1: array[19, byte]
FMovementProperties* {.exportcpp: "$1_".} = object
bCanCrouch*: bool
bCanJump*: bool
bCanWalk*: bool
bCanSwim*: bool
bCanFly*: bool
FNavAgentProperties* {.exportcpp: "$1_".} = object
pad_0: array[4, byte]
agentRadius*: float32
agentHeight*: float32
agentStepHeight*: float32
navWalkingSearchHeightScale*: float32
pad_1: array[4, byte]
preferredNavData*: FSoftClassPath
FNavDataConfig* {.exportcpp: "$1_".} = object
pad_0: array[64, byte]
name*: FName
color*: FColor
defaultQueryExtent*: FVector
pad_1: array[48, byte]
navDataClass*: TSoftClassPtr[AActor]
FAlphaBlendArgs* {.exportcpp: "$1_".} = object
customCurve*: UCurveFloatPtr
blendTime*: float32
blendOption*: EAlphaBlendOption
pad_0: array[3, byte]
FBlendSampleData* {.exportcpp: "$1_".} = object
pad_0: array[96, byte]
FMarkerSyncAnimPosition* {.exportcpp: "$1_".} = object
previousMarkerName*: FName
nextMarkerName*: FName
positionBetweenMarkers*: float32
FBoneAnimationTrack* {.exportcpp: "$1_".} = object
internalTrackData*: FRawAnimSequenceTrack
boneTreeIndex*: int32
name*: FName
FAnimationCurveData* {.exportcpp: "$1_".} = object
floatCurves*: TArray[FFloatCurve]
transformCurves*: TArray[FTransformCurve]
FAnimatedBoneAttribute* {.exportcpp: "$1_".} = object
identifier*: FAnimationAttributeIdentifier
curve*: FAttributeCurve
FAnimExecutionContext* {.exportcpp: "$1_".} = object
pad_0: array[16, byte]
FMontageBlendSettings* {.exportcpp: "$1_".} = object
blendProfile*: UBlendProfilePtr
blend*: FAlphaBlendArgs
blendMode*: EMontageBlendMode
pad_0: array[7, byte]
FAnimNodeData* {.exportcpp: "$1_".} = object
pad_0: array[40, byte]
FAnimNode_ConvertComponentToLocalSpace* {.exportcpp: "$1_".} = object
pad_0: array[136, byte]
componentPose*: FComponentSpacePoseLink
FAnimNode_ConvertLocalToComponentSpace* {.exportcpp: "$1_".} = object
pad_0: array[136, byte]
localPose*: FPoseLink
FAnimNode_ApplyMeshSpaceAdditive* {.exportcpp: "$1_".} = object
pad_0: array[136, byte]
base*: FPoseLink
additive*: FPoseLink
alphaInputType*: EAnimAlphaInputType
pad_1: array[3, byte]
alpha*: float32
bAlphaBoolEnabled*: bool
pad_2: array[7, byte]
alphaBoolBlend*: FInputAlphaBoolBlend
alphaCurveName*: FName
alphaScaleBias*: FInputScaleBias
alphaScaleBiasClamp*: FInputScaleBiasClamp
lODThreshold*: int32
pad_3: array[8, byte]
FAnimNode_Inertialization* {.exportcpp: "$1_".} = object
pad_0: array[384, byte]
FAnimNode_LinkedAnimGraph* {.exportcpp: "$1_".} = object
pad_0: array[328, byte]
FAnimNode_LinkedAnimLayer* {.exportcpp: "$1_".} = object
pad_0: array[376, byte]
FAnimNode_SaveCachedPose* {.exportcpp: "$1_".} = object
pad_0: array[136, byte]
pose*: FPoseLink
pad_1: array[232, byte]
FAnimNode_SequencePlayerBase* {.exportcpp: "$1_".} = object
pad_0: array[192, byte]
FInputScaleBiasClampState* {.exportcpp: "$1_".} = object
pad_0: array[8, byte]
FAnimNode_SequencePlayer* {.exportcpp: "$1_".} = object
pad_0: array[328, byte]
FInputScaleBiasClampConstants* {.exportcpp: "$1_".} = object
bMapRange*: bool
bClampResult*: bool
bInterpResult*: bool
pad_0: array[1, byte]
inRange*: FInputRange
outRange*: FInputRange
scale*: float32
bias*: float32
clampMin*: float32
clampMax*: float32
interpSpeedIncreasing*: float32
interpSpeedDecreasing*: float32
FAnimNode_SequencePlayer_Standalone* {.exportcpp: "$1_".} = object
pad_0: array[280, byte]
FAnimNode_TransitionPoseEvaluator* {.exportcpp: "$1_".} = object
pad_0: array[272, byte]
framesToCachePose*: int32
pad_1: array[4, byte]
dataSource*: EEvaluatorDataSource
pad_2: array[23, byte]
FAnimNode_TransitionResult* {.exportcpp: "$1_".} = object
pad_0: array[136, byte]
bCanEnterTransition*: bool
pad_1: array[23, byte]
FAnimNotifyEventReference* {.exportcpp: "$1_".} = object
pad_0: array[40, byte]
FAnimNode_SingleNode* {.exportcpp: "$1_".} = object
pad_0: array[136, byte]
sourcePose*: FPoseLink
pad_1: array[24, byte]
FCachedAnimStateData* {.exportcpp: "$1_".} = object
stateMachineName*: FName
stateName*: FName
pad_0: array[12, byte]
FCachedAnimStateArray* {.exportcpp: "$1_".} = object
states*: TArray[FCachedAnimStateData]
pad_0: array[8, byte]
FCachedAnimAssetPlayerData* {.exportcpp: "$1_".} = object
stateMachineName*: FName
stateName*: FName
pad_0: array[8, byte]
FCachedAnimRelevancyData* {.exportcpp: "$1_".} = object
stateMachineName*: FName
stateName*: FName
pad_0: array[12, byte]
FCachedAnimTransitionData* {.exportcpp: "$1_".} = object
stateMachineName*: FName
fromStateName*: FName
toStateName*: FName
pad_0: array[12, byte]
FNamedCurveValue* {.exportcpp: "$1_".} = object
name*: FName
value*: float32
FInputClampConstants* {.exportcpp: "$1_".} = object
bClampResult*: bool
bInterpResult*: bool
pad_0: array[2, byte]
clampMin*: float32
clampMax*: float32
interpSpeedIncreasing*: float32
interpSpeedDecreasing*: float32
FInputClampState* {.exportcpp: "$1_".} = object
pad_0: array[8, byte]
FTrajectorySample* {.exportcpp: "$1_".} = object
accumulatedSeconds*: float32
accumulatedDistance*: float32
pad_0: array[8, byte]
transform*: FTransform
linearVelocity*: FVector
pad_1: array[8, byte]
FTrajectorySampleRange* {.exportcpp: "$1_".} = object
samples*: TArray[FTrajectorySample]
sampleRate*: int32
pad_0: array[4, byte]
FAssetCompileData* {.exportcpp: "$1_".} = object
asset*: TWeakObjectPtr[UObject]
FAssetManagerSearchRules* {.exportcpp: "$1_".} = object
assetScanPaths*: TArray[FString]
includePatterns*: TArray[FString]
excludePatterns*: TArray[FString]
assetBaseClass*: UClassPtr
bHasBlueprintClasses*: bool
bForceSynchronousScan*: bool
bSkipVirtualPathExpansion*: bool
bSkipManagerIncludeCheck*: bool
pad_0: array[20, byte]
FAudioVolumeSubmixSendSettings* {.exportcpp: "$1_".} = object
listenerLocationState*: EAudioVolumeLocationState
pad_0: array[7, byte]
submixSends*: TArray[FSoundSubmixSendInfo]
FSoundSubmixSendInfo* {.exportcpp: "$1_".} = object
sendLevelControlMethod*: ESendLevelControlMethod
sendStage*: ESubmixSendStage
pad_0: array[6, byte]
soundSubmix*: USoundSubmixBasePtr
sendLevel*: float32
disableManualSendClamp*: bool
pad_1: array[3, byte]
minSendLevel*: float32
maxSendLevel*: float32
minSendDistance*: float32
maxSendDistance*: float32
customSendLevelCurve*: FRuntimeFloatCurve
FAudioVolumeSubmixOverrideSettings* {.exportcpp: "$1_".} = object
submix*: USoundSubmixPtr
submixEffectChain*: TArray[USoundEffectSubmixPresetPtr]
crossfadeTime*: float32
pad_0: array[4, byte]
FInteriorSettings* {.exportcpp: "$1_".} = object
pad_0: array[4, byte]
exteriorVolume*: float32
exteriorTime*: float32
exteriorLPF*: float32
exteriorLPFTime*: float32
interiorVolume*: float32
interiorTime*: float32
interiorLPF*: float32
interiorLPFTime*: float32
FCameraLensInterfaceClassSupport* {.exportcpp: "$1_".} = object
pad_0: array[8, byte]
FCameraShakeStartParams* {.exportcpp: "$1_".} = object
bIsRestarting*: bool
FCameraShakeUpdateParams* {.exportcpp: "$1_".} = object
deltaTime*: float32
shakeScale*: float32
dynamicScale*: float32
blendingWeight*: float32
pOV*: FMinimalViewInfo
FCameraShakeScrubParams* {.exportcpp: "$1_".} = object
absoluteTime*: float32
shakeScale*: float32
dynamicScale*: float32
blendingWeight*: float32
pOV*: FMinimalViewInfo
FCameraShakeUpdateResult* {.exportcpp: "$1_".} = object
pad_0: array[1888, byte]
FCameraShakeStopParams* {.exportcpp: "$1_".} = object
bImmediately*: bool
FCameraShakeDuration* {.exportcpp: "$1_".} = object
pad_0: array[8, byte]
FCameraShakeInfo* {.exportcpp: "$1_".} = object
pad_0: array[16, byte]
FFindFloorResult* {.exportcpp: "$1_".} = object
bBlockingHit*: bool
bWalkableFloor*: bool
bLineTrace*: bool
pad_0: array[1, byte]
floorDist*: float32
lineDist*: float32
pad_1: array[4, byte]
hitResult*: FHitResult
FLODMappingData* {.exportcpp: "$1_".} = object
mapping*: TArray[int32]
pad_0: array[16, byte]
FComponentSync* {.exportcpp: "$1_".} = object
name*: FName
syncOption*: ESyncOption
pad_0: array[3, byte]
FMaterialSpriteElement* {.exportcpp: "$1_".} = object
material*: UMaterialInterfacePtr
distanceToOpacityCurve*: UCurveFloatPtr
bSizeIsInScreenSpace*: bool
pad_0: array[3, byte]
baseSizeX*: float32
baseSizeY*: float32
pad_1: array[4, byte]
distanceToSizeCurve*: UCurveFloatPtr
FEngineShowFlagsSetting* {.exportcpp: "$1_".} = object
showFlagName*: FString
enabled*: bool
pad_0: array[7, byte]
FTentDistribution* {.exportcpp: "$1_".} = object
tipAltitude*: float32
tipValue*: float32
width*: float32
FSplinePoint* {.exportcpp: "$1_".} = object
inputKey*: float32
pad_0: array[4, byte]
position*: FVector
arriveTangent*: FVector
leaveTangent*: FVector
rotation*: FRotator
scale*: FVector
`type`*: ESplinePointType
pad_1: array[7, byte]
FCullDistanceSizePair* {.exportcpp: "$1_".} = object
size*: float32
cullDistance*: float32
FRuntimeVectorCurve* {.exportcpp: "$1_".} = object
pad_0: array[392, byte]
FCurveTableRowHandle* {.exportcpp: "$1_".} = object
curveTable*: UCurveTablePtr
rowName*: FName
pad_0: array[4, byte]
FDataDrivenConsoleVariable* {.exportcpp: "$1_".} = object
pad_0: array[80, byte]
FDataTableRowHandle* {.exportcpp: "$1_".} = object
dataTable*: UDataTablePtr
rowName*: FName
pad_0: array[4, byte]
FDataTableCategoryHandle* {.exportcpp: "$1_".} = object
dataTable*: UDataTablePtr
columnName*: FName
rowContents*: FName
FDialogueContext* {.exportcpp: "$1_".} = object
speaker*: UDialogueVoicePtr
targets*: TArray[UDialogueVoicePtr]
FTypedElementDeletionOptions* {.exportcpp: "$1_".} = object
bVerifyDeletionCanHappen*: bool
bWarnAboutReferences*: bool
bWarnAboutSoftReferences*: bool
FDamageEvent* {.exportcpp: "$1_".} = object
pad_0: array[16, byte]
FRadialDamageParams* {.exportcpp: "$1_".} = object
baseDamage*: float32
minimumDamage*: float32
innerRadius*: float32
outerRadius*: float32
damageFalloff*: float32
FSlateModifierKeysState* {.exportcpp: "$1_".} = object
pad_0: array[1, byte]
FFloatSpringState* {.exportcpp: "$1_".} = object
pad_0: array[12, byte]
FVectorSpringState* {.exportcpp: "$1_".} = object
pad_0: array[56, byte]
FQuaternionSpringState* {.exportcpp: "$1_".} = object
pad_0: array[64, byte]
FDrawToRenderTargetContext* {.exportcpp: "$1_".} = object
pad_0: array[16, byte]
FImportanceTexture* {.exportcpp: "$1_".} = object
pad_0: array[80, byte]
FScalarParameterValue* {.exportcpp: "$1_".} = object
pad_0: array[136, byte]
parameterInfo*: FMaterialParameterInfo
parameterValue*: float32
pad_1: array[16, byte]
FVectorParameterValue* {.exportcpp: "$1_".} = object
pad_0: array[12, byte]
parameterInfo*: FMaterialParameterInfo
parameterValue*: FLinearColor
pad_1: array[16, byte]
FDoubleVectorParameterValue* {.exportcpp: "$1_".} = object
parameterInfo*: FMaterialParameterInfo
pad_0: array[60, byte]
FTextureParameterValue* {.exportcpp: "$1_".} = object
pad_0: array[12, byte]
parameterInfo*: FMaterialParameterInfo
parameterValue*: UTexturePtr
pad_1: array[16, byte]
FRuntimeVirtualTextureParameterValue* {.exportcpp: "$1_".} = object
parameterInfo*: FMaterialParameterInfo
pad_0: array[4, byte]
parameterValue*: URuntimeVirtualTexturePtr
pad_1: array[16, byte]
FFontParameterValue* {.exportcpp: "$1_".} = object
pad_0: array[12, byte]
parameterInfo*: FMaterialParameterInfo
fontValue*: UFontPtr
fontPage*: int32
pad_1: array[20, byte]
FMeshReductionSettings* {.exportcpp: "$1_".} = object
percentTriangles*: float32
percentVertices*: float32
maxDeviation*: float32
pixelError*: float32
weldingThreshold*: float32
hardAngleThreshold*: float32
baseLODModel*: int32
silhouetteImportance*: EMeshFeatureImportance
textureImportance*: EMeshFeatureImportance
shadingImportance*: EMeshFeatureImportance
bRecalculateNormals*: bool
bGenerateUniqueLightmapUVs*: bool
bKeepSymmetry*: bool
bVisibilityAided*: bool
bCullOccluded*: bool
terminationCriterion*: EStaticMeshReductionTerimationCriterion
visibilityAggressiveness*: EMeshFeatureImportance
vertexColorImportance*: EMeshFeatureImportance
FMeshInstancingSettings* {.exportcpp: "$1_".} = object
actorClassToUse*: TSubclassOf[AActor]
instanceReplacementThreshold*: int32
bSkipMeshesWithVertexColors*: bool
bUseHLODVolumes*: bool
pad_0: array[2, byte]
iSMComponentToUse*: TSubclassOf[UInstancedStaticMeshComponent]
FUniqueNetIdRepl* {.exportcpp: "$1_".} = object
pad_0: array[48, byte]
FConstraintInstanceAccessor* {.exportcpp: "$1_".} = object
pad_0: array[96, byte]
FPhysicalAnimationData* {.exportcpp: "$1_".} = object
pad_0: array[12, byte]
bIsLocalSimulation*: bool
pad_1: array[3, byte]
orientationStrength*: float32
angularVelocityStrength*: float32
positionStrength*: float32
velocityStrength*: float32
maxLinearForce*: float32
maxAngularForce*: float32
FPhysicsAssetSolverSettings* {.exportcpp: "$1_".} = object
positionIterations*: int32
velocityIterations*: int32
projectionIterations*: int32
cullDistance*: float32
maxDepenetrationVelocity*: float32
fixedTimeStep*: float32
bUseLinearJointSolver*: bool
pad_0: array[3, byte]
FSolverIterations* {.exportcpp: "$1_".} = object
solverIterations*: int32
jointIterations*: int32
collisionIterations*: int32
solverPushOutIterations*: int32
jointPushOutIterations*: int32
collisionPushOutIterations*: int32
FSubsurfaceProfileStruct* {.exportcpp: "$1_".} = object
surfaceAlbedo*: FLinearColor
meanFreePathColor*: FLinearColor
meanFreePathDistance*: float32
worldUnitScale*: float32
bEnableBurley*: bool
bEnableMeanFreePath*: bool
pad_0: array[2, byte]
tint*: FLinearColor
scatterRadius*: float32
subsurfaceColor*: FLinearColor
falloffColor*: FLinearColor
boundaryColorBleed*: FLinearColor
extinctionScale*: float32
normalScale*: float32
scatteringDistribution*: float32
iOR*: float32
roughness0*: float32
roughness1*: float32
lobeMix*: float32
transmissionTintColor*: FLinearColor
FSingleAnimationPlayData* {.exportcpp: "$1_".} = object
animToPlay*: UAnimationAssetPtr
bSavedLooping*: bool
bSavedPlaying*: bool
pad_0: array[2, byte]
savedPosition*: float32
savedPlayRate*: float32
pad_1: array[4, byte]
FSkelMeshMergeSectionMapping* {.exportcpp: "$1_".} = object
sectionIDs*: TArray[int32]
FSkelMeshMergeMeshUVTransforms* {.exportcpp: "$1_".} = object
uVTransforms*: TArray[FTransform]
FSkelMeshMergeUVTransformMapping* {.exportcpp: "$1_".} = object
uVTransformsPerMesh*: TArray[FSkelMeshMergeMeshUVTransforms]
FSoundClassProperties* {.exportcpp: "$1_".} = object
volume*: float32
pitch*: float32
lowPassFilterFrequency*: float32
attenuationDistanceScale*: float32
lFEBleed*: float32
voiceCenterChannelVolume*: float32
radioFilterVolume*: float32
radioFilterVolumeThreshold*: float32
bApplyEffects*: bool
bAlwaysPlay*: bool
bIsUISound*: bool
bIsMusic*: bool
bCenterChannelOnly*: bool
bApplyAmbientVolumes*: bool
bReverb*: bool
default2DReverbSendAmount*: float32
modulationSettings*: FSoundModulationDefaultSettings
outputTarget*: EAudioOutputTarget
loadingBehavior*: ESoundWaveLoadingBehavior
pad_0: array[3, byte]
defaultSubmix*: USoundSubmixPtr
FSoundModulationDefaultSettings* {.exportcpp: "$1_".} = object
volumeModulationDestination*: FSoundModulationDestinationSettings
pitchModulationDestination*: FSoundModulationDestinationSettings
highpassModulationDestination*: FSoundModulationDestinationSettings
lowpassModulationDestination*: FSoundModulationDestinationSettings
FSoundModulationDestinationSettings* {.exportcpp: "$1_".} = object
value*: float32
pad_0: array[4, byte]
modulator*: USoundModulatorBasePtr
modulators*: TSet[USoundModulatorBasePtr]
FPassiveSoundMixModifier* {.exportcpp: "$1_".} = object
soundMix*: USoundMixPtr
minVolumeThreshold*: float32
maxVolumeThreshold*: float32
FSoundConcurrencySettings* {.exportcpp: "$1_".} = object
maxCount*: int32
bLimitToOwner*: bool
bVolumeScaleCanRelease*: bool
resolutionRule*: EMaxConcurrentResolutionRule
pad_0: array[1, byte]
retriggerTime*: float32
pad_1: array[4, byte]
volumeScaleMode*: EConcurrencyVolumeScaleMode
volumeScaleAttackTime*: float32
volumeScaleReleaseTime*: float32
voiceStealReleaseTime*: float32
FSoundClassAdjuster* {.exportcpp: "$1_".} = object
soundClassObject*: USoundClassPtr
volumeAdjuster*: float32
pitchAdjuster*: float32
lowPassFilterFrequency*: float32
bApplyToChildren*: bool
pad_0: array[3, byte]
voiceCenterChannelVolumeAdjuster*: float32
pad_1: array[4, byte]
FSoundModulationDefaultRoutingSettings* {.exportcpp: "$1_".} = object
pad_0: array[384, byte]
volumeRouting*: EModulationRouting
pitchRouting*: EModulationRouting
highpassRouting*: EModulationRouting
lowpassRouting*: EModulationRouting
pad_1: array[4, byte]
FSoundSubmixSpectralAnalysisBandSettings* {.exportcpp: "$1_".} = object
bandFrequency*: float32
attackTimeMsec*: int32
releaseTimeMsec*: int32
qFactor*: float32
FCanvasIcon* {.exportcpp: "$1_".} = object
texture*: UTexturePtr
u*: float32
v*: float32
uL*: float32
vL*: float32
FInputActionKeyMapping* {.exportcpp: "$1_".} = object
actionName*: FName
bShift*: bool
bCtrl*: bool
bAlt*: bool
bCmd*: bool
key*: FKey
FInputAxisKeyMapping* {.exportcpp: "$1_".} = object
axisName*: FName
scale*: float32
key*: FKey
FInputActionSpeechMapping* {.exportcpp: "$1_".} = object
pad_0: array[24, byte]
FVoiceSettings* {.exportcpp: "$1_".} = object
componentToAttachTo*: USceneComponentPtr
attenuationSettings*: USoundAttenuationPtr
sourceEffectChain*: USoundEffectSourcePresetChainPtr
FActorDesc* {.exportcpp: "$1_".} = object
guid*: FGuid
Class*: FSoftObjectPath
name*: FName
label*: FName
bounds*: FBox
runtimeGrid*: FName
bIsSpatiallyLoaded*: bool
bActorIsEditorOnly*: bool
pad_0: array[2, byte]
actorPackage*: FName
actorPath*: FName
FPlatformDelegate* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FPlatformFailedToRegisterForRemoteNotificationsDelegate*
{.exportcpp: "$1_".} = object of FMulticastScriptDelegate
FPlatformReceivedLocalNotificationDelegate*
{.exportcpp: "$1_".} = object of FMulticastScriptDelegate
FPlatformReceivedRemoteNotificationDelegate*
{.exportcpp: "$1_".} = object of FMulticastScriptDelegate
FPlatformRegisteredForRemoteNotificationsDelegate*
{.exportcpp: "$1_".} = object of FMulticastScriptDelegate
FPlatformRegisteredForUserNotificationsDelegate*
{.exportcpp: "$1_".} = object of FMulticastScriptDelegate
FPlatformScreenOrientationChangedDelegate*
{.exportcpp: "$1_".} = object of FMulticastScriptDelegate
FPlatformStartupArgumentsDelegate*
{.exportcpp: "$1_".} = object of FMulticastScriptDelegate
FOnAssetLoaded* {.exportcpp: "$1_".} = object of
FScriptDelegate
FOnAssetClassLoaded* {.exportcpp: "$1_".} = object of
FScriptDelegate
FOnDataDrivenCVarChanged* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnProjectileBounceDelegate* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnProjectileStopDelegate* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FPlatformEventDelegate* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnInterpToResetDelegate* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnInterpToReverseDelegate* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnInterpToStopDelegate* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnInterpToWaitBeginDelegate* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FOnInterpToWaitEndDelegate* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FApplicationLifetimeDelegate* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
FApplicationStartupArgumentsDelegate*
{.exportcpp: "$1_".} = object of FMulticastScriptDelegate
FOnLowPowerModeDelegate* {.exportcpp: "$1_".} = object of
FMulticastScriptDelegate
proc keepUSubsystem(fake : USubsystem) {.exportcpp.} =
discard
proc keepUDynamicSubsystem(fake : UDynamicSubsystem) {.exportcpp.} =
discard
proc `bOnlyRelevantToOwner`*(obj : AActorPtr): bool {.exportcpp.} =
let prop = getClassByName("Actor").getFPropertyByName(
"bOnlyRelevantToOwner")
getValueFromBoolProp(prop, obj)
proc `bOnlyRelevantToOwner=`*(obj : AActorPtr; val : bool) =
var value : bool = val
let prop = getClassByName("Actor").getFPropertyByName(
"bOnlyRelevantToOwner")
setValueInBoolProp(prop, obj, value)
proc `set bOnlyRelevantToOwner`*(obj : AActorPtr; val : bool) {.
exportcpp.} =
var value : bool = val
let prop = getClassByName("Actor").getFPropertyByName(
"bOnlyRelevantToOwner")
setValueInBoolProp(prop, obj, value)
proc `bAlwaysRelevant`*(obj : AActorPtr): bool {.exportcpp.} =
let prop = getClassByName("Actor").getFPropertyByName(
"bAlwaysRelevant")
getValueFromBoolProp(prop, obj)
proc `bAlwaysRelevant=`*(obj : AActorPtr; val : bool) =
var value : bool = val
let prop = getClassByName("Actor").getFPropertyByName(
"bAlwaysRelevant")
setValueInBoolProp(prop, obj, value)
proc `set bAlwaysRelevant`*(obj : AActorPtr; val : bool) {.
exportcpp.} =
var value : bool = val
let prop = getClassByName("Actor").getFPropertyByName(
"bAlwaysRelevant")
setValueInBoolProp(prop, obj, value)
proc `bHidden`*(obj : AActorPtr): bool {.exportcpp.} =
let prop = getClassByName("Actor").getFPropertyByName("bHidden")
getValueFromBoolProp(prop, obj)
proc `bHidden=`*(obj : AActorPtr; val : bool) =
var value : bool = val
let prop = getClassByName("Actor").getFPropertyByName("bHidden")
setValueInBoolProp(prop, obj, value)
proc `set bHidden`*(obj : AActorPtr; val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("Actor").getFPropertyByName("bHidden")
setValueInBoolProp(prop, obj, value)
proc `bNetUseOwnerRelevancy`*(obj : AActorPtr): bool {.exportcpp.} =
let prop = getClassByName("Actor").getFPropertyByName(
"bNetUseOwnerRelevancy")
getValueFromBoolProp(prop, obj)
proc `bNetUseOwnerRelevancy=`*(obj : AActorPtr; val : bool) =
var value : bool = val
let prop = getClassByName("Actor").getFPropertyByName(
"bNetUseOwnerRelevancy")
setValueInBoolProp(prop, obj, value)
proc `set bNetUseOwnerRelevancy`*(obj : AActorPtr; val : bool) {.
exportcpp.} =
var value : bool = val
let prop = getClassByName("Actor").getFPropertyByName(
"bNetUseOwnerRelevancy")
setValueInBoolProp(prop, obj, value)
proc `bAutoDestroyWhenFinished`*(obj : AActorPtr): bool {.exportcpp.} =
let prop = getClassByName("Actor").getFPropertyByName(
"bAutoDestroyWhenFinished")
getValueFromBoolProp(prop, obj)
proc `bAutoDestroyWhenFinished=`*(obj : AActorPtr; val : bool) =
var value : bool = val
let prop = getClassByName("Actor").getFPropertyByName(
"bAutoDestroyWhenFinished")
setValueInBoolProp(prop, obj, value)
proc `set bAutoDestroyWhenFinished`*(obj : AActorPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("Actor").getFPropertyByName(
"bAutoDestroyWhenFinished")
setValueInBoolProp(prop, obj, value)
proc `bCanBeDamaged`*(obj : AActorPtr): bool {.exportcpp.} =
let prop = getClassByName("Actor").getFPropertyByName(
"bCanBeDamaged")
getValueFromBoolProp(prop, obj)
proc `bCanBeDamaged=`*(obj : AActorPtr; val : bool) =
var value : bool = val
let prop = getClassByName("Actor").getFPropertyByName(
"bCanBeDamaged")
setValueInBoolProp(prop, obj, value)
proc `set bCanBeDamaged`*(obj : AActorPtr; val : bool) {.
exportcpp.} =
var value : bool = val
let prop = getClassByName("Actor").getFPropertyByName(
"bCanBeDamaged")
setValueInBoolProp(prop, obj, value)
proc `bFindCameraComponentWhenViewTarget`*(obj : AActorPtr): bool {.
exportcpp.} =
let prop = getClassByName("Actor").getFPropertyByName(
"bFindCameraComponentWhenViewTarget")
getValueFromBoolProp(prop, obj)
proc `bFindCameraComponentWhenViewTarget=`*(obj : AActorPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("Actor").getFPropertyByName(
"bFindCameraComponentWhenViewTarget")
setValueInBoolProp(prop, obj, value)
proc `set bFindCameraComponentWhenViewTarget`*(obj : AActorPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("Actor").getFPropertyByName(
"bFindCameraComponentWhenViewTarget")
setValueInBoolProp(prop, obj, value)
proc `bGenerateOverlapEventsDuringLevelStreaming`*(obj : AActorPtr): bool {.
exportcpp.} =
let prop = getClassByName("Actor").getFPropertyByName(
"bGenerateOverlapEventsDuringLevelStreaming")
getValueFromBoolProp(prop, obj)
proc `bGenerateOverlapEventsDuringLevelStreaming=`*(obj : AActorPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("Actor").getFPropertyByName(
"bGenerateOverlapEventsDuringLevelStreaming")
setValueInBoolProp(prop, obj, value)
proc `set bGenerateOverlapEventsDuringLevelStreaming`*(obj : AActorPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("Actor").getFPropertyByName(
"bGenerateOverlapEventsDuringLevelStreaming")
setValueInBoolProp(prop, obj, value)
proc `bEnableAutoLODGeneration`*(obj : AActorPtr): bool {.exportcpp.} =
let prop = getClassByName("Actor").getFPropertyByName(
"bEnableAutoLODGeneration")
getValueFromBoolProp(prop, obj)
proc `bEnableAutoLODGeneration=`*(obj : AActorPtr; val : bool) =
var value : bool = val
let prop = getClassByName("Actor").getFPropertyByName(
"bEnableAutoLODGeneration")
setValueInBoolProp(prop, obj, value)
proc `set bEnableAutoLODGeneration`*(obj : AActorPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("Actor").getFPropertyByName(
"bEnableAutoLODGeneration")
setValueInBoolProp(prop, obj, value)
proc `bReplicates`*(obj : AActorPtr): bool {.exportcpp.} =
let prop = getClassByName("Actor").getFPropertyByName("bReplicates")
getValueFromBoolProp(prop, obj)
proc `bReplicates=`*(obj : AActorPtr; val : bool) =
var value : bool = val
let prop = getClassByName("Actor").getFPropertyByName("bReplicates")
setValueInBoolProp(prop, obj, value)
proc `set bReplicates`*(obj : AActorPtr; val : bool) {.
exportcpp.} =
var value : bool = val
let prop = getClassByName("Actor").getFPropertyByName("bReplicates")
setValueInBoolProp(prop, obj, value)
proc `bReplicateUsingRegisteredSubObjectList`*(obj : AActorPtr): bool {.
exportcpp.} =
let prop = getClassByName("Actor").getFPropertyByName(
"bReplicateUsingRegisteredSubObjectList")
getValueFromBoolProp(prop, obj)
proc `bReplicateUsingRegisteredSubObjectList=`*(obj : AActorPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("Actor").getFPropertyByName(
"bReplicateUsingRegisteredSubObjectList")
setValueInBoolProp(prop, obj, value)
proc `set bReplicateUsingRegisteredSubObjectList`*(obj : AActorPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("Actor").getFPropertyByName(
"bReplicateUsingRegisteredSubObjectList")
setValueInBoolProp(prop, obj, value)
proc `initialLifeSpan`*(obj : AActorPtr): float32 {.exportcpp.} =
let prop = getClassByName("Actor").getFPropertyByName(
"InitialLifeSpan")
getPropertyValuePtr[float32](prop, obj)[]
proc `initialLifeSpan=`*(obj : AActorPtr; val : float32) =
var value : float32 = val
let prop = getClassByName("Actor").getFPropertyByName(
"InitialLifeSpan")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set initialLifeSpan`*(obj : AActorPtr; val : float32) {.
exportcpp.} =
var value : float32 = val
let prop = getClassByName("Actor").getFPropertyByName(
"InitialLifeSpan")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `customTimeDilation`*(obj : AActorPtr): float32 {.exportcpp.} =
let prop = getClassByName("Actor").getFPropertyByName(
"CustomTimeDilation")
getPropertyValuePtr[float32](prop, obj)[]
proc `customTimeDilation=`*(obj : AActorPtr; val : float32) =
var value : float32 = val
let prop = getClassByName("Actor").getFPropertyByName(
"CustomTimeDilation")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set customTimeDilation`*(obj : AActorPtr; val : float32) {.
exportcpp.} =
var value : float32 = val
let prop = getClassByName("Actor").getFPropertyByName(
"CustomTimeDilation")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `netDormancy`*(obj : AActorPtr): ENetDormancy {.exportcpp.} =
let prop = getClassByName("Actor").getFPropertyByName("NetDormancy")
getPropertyValuePtr[ENetDormancy](prop, obj)[]
proc `netDormancy=`*(obj : AActorPtr; val : ENetDormancy) =
var value : ENetDormancy = val
let prop = getClassByName("Actor").getFPropertyByName("NetDormancy")
setPropertyValuePtr[ENetDormancy](prop, obj, value.addr)
proc `set netDormancy`*(obj : AActorPtr; val : ENetDormancy) {.
exportcpp.} =
var value : ENetDormancy = val
let prop = getClassByName("Actor").getFPropertyByName("NetDormancy")
setPropertyValuePtr[ENetDormancy](prop, obj, value.addr)
proc `spawnCollisionHandlingMethod`*(obj : AActorPtr): ESpawnActorCollisionHandlingMethod {.
exportcpp.} =
let prop = getClassByName("Actor").getFPropertyByName(
"SpawnCollisionHandlingMethod")
getPropertyValuePtr[ESpawnActorCollisionHandlingMethod](prop, obj)[]
proc `spawnCollisionHandlingMethod=`*(obj : AActorPtr; val : ESpawnActorCollisionHandlingMethod) =
var value : ESpawnActorCollisionHandlingMethod = val
let prop = getClassByName("Actor").getFPropertyByName(
"SpawnCollisionHandlingMethod")
setPropertyValuePtr[ESpawnActorCollisionHandlingMethod](prop, obj, value.addr)
proc `set spawnCollisionHandlingMethod`*(obj : AActorPtr;
val : ESpawnActorCollisionHandlingMethod) {.exportcpp.} =
var value : ESpawnActorCollisionHandlingMethod = val
let prop = getClassByName("Actor").getFPropertyByName(
"SpawnCollisionHandlingMethod")
setPropertyValuePtr[ESpawnActorCollisionHandlingMethod](prop, obj, value.addr)
proc `netCullDistanceSquared`*(obj : AActorPtr): float32 {.exportcpp.} =
let prop = getClassByName("Actor").getFPropertyByName(
"NetCullDistanceSquared")
getPropertyValuePtr[float32](prop, obj)[]
proc `netCullDistanceSquared=`*(obj : AActorPtr;
val : float32) =
var value : float32 = val
let prop = getClassByName("Actor").getFPropertyByName(
"NetCullDistanceSquared")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set netCullDistanceSquared`*(obj : AActorPtr;
val : float32) {.exportcpp.} =
var value : float32 = val
let prop = getClassByName("Actor").getFPropertyByName(
"NetCullDistanceSquared")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `netUpdateFrequency`*(obj : AActorPtr): float32 {.exportcpp.} =
let prop = getClassByName("Actor").getFPropertyByName(
"NetUpdateFrequency")
getPropertyValuePtr[float32](prop, obj)[]
proc `netUpdateFrequency=`*(obj : AActorPtr; val : float32) =
var value : float32 = val
let prop = getClassByName("Actor").getFPropertyByName(
"NetUpdateFrequency")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set netUpdateFrequency`*(obj : AActorPtr; val : float32) {.
exportcpp.} =
var value : float32 = val
let prop = getClassByName("Actor").getFPropertyByName(
"NetUpdateFrequency")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `minNetUpdateFrequency`*(obj : AActorPtr): float32 {.exportcpp.} =
let prop = getClassByName("Actor").getFPropertyByName(
"MinNetUpdateFrequency")
getPropertyValuePtr[float32](prop, obj)[]
proc `minNetUpdateFrequency=`*(obj : AActorPtr; val : float32) =
var value : float32 = val
let prop = getClassByName("Actor").getFPropertyByName(
"MinNetUpdateFrequency")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set minNetUpdateFrequency`*(obj : AActorPtr;
val : float32) {.exportcpp.} =
var value : float32 = val
let prop = getClassByName("Actor").getFPropertyByName(
"MinNetUpdateFrequency")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `netPriority`*(obj : AActorPtr): float32 {.exportcpp.} =
let prop = getClassByName("Actor").getFPropertyByName("NetPriority")
getPropertyValuePtr[float32](prop, obj)[]
proc `netPriority=`*(obj : AActorPtr; val : float32) =
var value : float32 = val
let prop = getClassByName("Actor").getFPropertyByName("NetPriority")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set netPriority`*(obj : AActorPtr; val : float32) {.
exportcpp.} =
var value : float32 = val
let prop = getClassByName("Actor").getFPropertyByName("NetPriority")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `instigator`*(obj : AActorPtr): APawnPtr {.exportcpp.} =
let prop = getClassByName("Actor").getFPropertyByName("Instigator")
getPropertyValuePtr[APawnPtr](prop, obj)[]
proc `instigator=`*(obj : AActorPtr; val : APawnPtr) =
var value : APawnPtr = val
let prop = getClassByName("Actor").getFPropertyByName("Instigator")
setPropertyValuePtr[APawnPtr](prop, obj, value.addr)
proc `set instigator`*(obj : AActorPtr; val : APawnPtr) {.
exportcpp.} =
var value : APawnPtr = val
let prop = getClassByName("Actor").getFPropertyByName("Instigator")
setPropertyValuePtr[APawnPtr](prop, obj, value.addr)
proc `pivotOffset`*(obj : AActorPtr): var FVector {.exportcpp.} =
let prop = getClassByName("Actor").getFPropertyByName("PivotOffset")
getPropertyValuePtr[FVector](prop, obj)[]
proc `pivotOffset=`*(obj : AActorPtr; val : FVector) =
var value : FVector = val
let prop = getClassByName("Actor").getFPropertyByName("PivotOffset")
setPropertyValuePtr[FVector](prop, obj, value.addr)
proc `set pivotOffset`*(obj : AActorPtr; val : FVector) {.
exportcpp.} =
var value : FVector = val
let prop = getClassByName("Actor").getFPropertyByName("PivotOffset")
setPropertyValuePtr[FVector](prop, obj, value.addr)
proc `actorGuid`*(obj : AActorPtr): var FGuid {.exportcpp.} =
let prop = getClassByName("Actor").getFPropertyByName("ActorGuid")
getPropertyValuePtr[FGuid](prop, obj)[]
proc `actorGuid=`*(obj : AActorPtr; val : FGuid) =
var value : FGuid = val
let prop = getClassByName("Actor").getFPropertyByName("ActorGuid")
setPropertyValuePtr[FGuid](prop, obj, value.addr)
proc `set actorGuid`*(obj : AActorPtr; val : FGuid) {.
exportcpp.} =
var value : FGuid = val
let prop = getClassByName("Actor").getFPropertyByName("ActorGuid")
setPropertyValuePtr[FGuid](prop, obj, value.addr)
proc `contentBundleGuid`*(obj : AActorPtr): var FGuid {.exportcpp.} =
let prop = getClassByName("Actor").getFPropertyByName(
"ContentBundleGuid")
getPropertyValuePtr[FGuid](prop, obj)[]
proc `contentBundleGuid=`*(obj : AActorPtr; val : FGuid) =
var value : FGuid = val
let prop = getClassByName("Actor").getFPropertyByName(
"ContentBundleGuid")
setPropertyValuePtr[FGuid](prop, obj, value.addr)
proc `set contentBundleGuid`*(obj : AActorPtr; val : FGuid) {.
exportcpp.} =
var value : FGuid = val
let prop = getClassByName("Actor").getFPropertyByName(
"ContentBundleGuid")
setPropertyValuePtr[FGuid](prop, obj, value.addr)
proc `spriteScale`*(obj : AActorPtr): float32 {.exportcpp.} =
let prop = getClassByName("Actor").getFPropertyByName("SpriteScale")
getPropertyValuePtr[float32](prop, obj)[]
proc `spriteScale=`*(obj : AActorPtr; val : float32) =
var value : float32 = val
let prop = getClassByName("Actor").getFPropertyByName("SpriteScale")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set spriteScale`*(obj : AActorPtr; val : float32) {.
exportcpp.} =
var value : float32 = val
let prop = getClassByName("Actor").getFPropertyByName("SpriteScale")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `tags`*(obj : AActorPtr): var TArray[FName] {.exportcpp.} =
let prop = getClassByName("Actor").getFPropertyByName("Tags")
getPropertyValuePtr[TArray[FName]](prop, obj)[]
proc `tags=`*(obj : AActorPtr; val : TArray[FName]) =
var value : TArray[FName] = val
let prop = getClassByName("Actor").getFPropertyByName("Tags")
setPropertyValuePtr[TArray[FName]](prop, obj, value.addr)
proc `set tags`*(obj : AActorPtr; val : TArray[FName]) {.
exportcpp.} =
var value : TArray[FName] = val
let prop = getClassByName("Actor").getFPropertyByName("Tags")
setPropertyValuePtr[TArray[FName]](prop, obj, value.addr)
proc wasRecentlyRendered*(self : AActorPtr;
tolerance : float32 = 0.2'f32): bool {.
exportcpp: "$1_".} =
type
Params = object
tolerance: float32
returnValue: bool
var param = Params(tolerance: tolerance)
let fnName {.used.} = n "WasRecentlyRendered"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc tearOff*(self : AActorPtr): void {.exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "TearOff"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc setTickGroup*(self : AActorPtr;
newTickGroup : ETickingGroup): void {.
exportcpp: "$1_".} =
type
Params = object
newTickGroup: ETickingGroup
var param = Params(newTickGroup: newTickGroup)
let fnName {.used.} = n "SetTickGroup"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc setTickableWhenPaused*(self : AActorPtr;
bTickableWhenPaused : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bTickableWhenPaused: bool
var param = Params(bTickableWhenPaused: bTickableWhenPaused)
let fnName {.used.} = n "SetTickableWhenPaused"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc setReplicates*(self : AActorPtr; bInReplicates : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bInReplicates: bool
var param = Params(bInReplicates: bInReplicates)
let fnName {.used.} = n "SetReplicates"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc setReplicateMovement*(self : AActorPtr;
bInReplicateMovement : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bInReplicateMovement: bool
var param = Params(bInReplicateMovement: bInReplicateMovement)
let fnName {.used.} = n "SetReplicateMovement"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc setRayTracingGroupId*(self : AActorPtr;
inRaytracingGroupId : int32): void {.
exportcpp: "$1_".} =
type
Params = object
inRaytracingGroupId: int32
var param = Params(inRaytracingGroupId: inRaytracingGroupId)
let fnName {.used.} = n "SetRayTracingGroupId"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc setOwner*(self : AActorPtr; newOwner : AActorPtr): void {.
exportcpp: "$1_".} =
type
Params = object
newOwner: AActorPtr
var param = Params(newOwner: newOwner)
let fnName {.used.} = n "SetOwner"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc setNetDormancy*(self : AActorPtr;
newDormancy : ENetDormancy): void {.
exportcpp: "$1_".} =
type
Params = object
newDormancy: ENetDormancy
var param = Params(newDormancy: newDormancy)
let fnName {.used.} = n "SetNetDormancy"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc setLifeSpan*(self : AActorPtr; inLifespan : float32): void {.
exportcpp: "$1_".} =
type
Params = object
inLifespan: float32
var param = Params(inLifespan: inLifespan)
let fnName {.used.} = n "SetLifeSpan"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc setIsTemporarilyHiddenInEditor*(self : AActorPtr;
bIsHidden : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bIsHidden: bool
var param = Params(bIsHidden: bIsHidden)
let fnName {.used.} = n "SetIsTemporarilyHiddenInEditor"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc setFolderPath*(self : AActorPtr;
newFolderPath : var FName): void {.
exportcpp: "$1_".} =
type
Params = object
newFolderPath: FName
var param = Params(newFolderPath: newFolderPath)
let fnName {.used.} = n "SetFolderPath"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
newFolderPath = param.newFolderPath
proc setAutoDestroyWhenFinished*(self : AActorPtr;
bVal : bool): void {.exportcpp: "$1_".} =
type
Params = object
bVal: bool
var param = Params(bVal: bVal)
let fnName {.used.} = n "SetAutoDestroyWhenFinished"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc setActorTickInterval*(self : AActorPtr;
tickInterval : float32): void {.
exportcpp: "$1_".} =
type
Params = object
tickInterval: float32
var param = Params(tickInterval: tickInterval)
let fnName {.used.} = n "SetActorTickInterval"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc setActorTickEnabled*(self : AActorPtr; bEnabled : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bEnabled: bool
var param = Params(bEnabled: bEnabled)
let fnName {.used.} = n "SetActorTickEnabled"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc setActorScale3D*(self : AActorPtr; newScale3D : FVector): void {.
exportcpp: "$1_".} =
type
Params = object
newScale3D: FVector
var param = Params(newScale3D: newScale3D)
let fnName {.used.} = n "SetActorScale3D"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc setActorRelativeScale3D*(self : AActorPtr;
newRelativeScale : FVector): void {.
exportcpp: "$1_".} =
type
Params = object
newRelativeScale: FVector
var param = Params(newRelativeScale: newRelativeScale)
let fnName {.used.} = n "SetActorRelativeScale3D"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc setActorLabel*(self : AActorPtr;
newActorLabel : FString;
bMarkDirty : bool = true): void {.exportcpp: "$1_".} =
type
Params = object
newActorLabel: FString
bMarkDirty: bool
var param = Params(newActorLabel: newActorLabel,
bMarkDirty: bMarkDirty)
let fnName {.used.} = n "SetActorLabel"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc setActorHiddenInGame*(self : AActorPtr;
bNewHidden : bool): void {.exportcpp: "$1_".} =
type
Params = object
bNewHidden: bool
var param = Params(bNewHidden: bNewHidden)
let fnName {.used.} = n "SetActorHiddenInGame"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc setActorEnableCollision*(self : AActorPtr;
bNewActorEnableCollision : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bNewActorEnableCollision: bool
var param = Params(bNewActorEnableCollision: bNewActorEnableCollision)
let fnName {.used.} = n "SetActorEnableCollision"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc removeTickPrerequisiteComponent*(self : AActorPtr;
prerequisiteComponent : UActorComponentPtr): void {.
exportcpp: "$1_".} =
type
Params = object
prerequisiteComponent: UActorComponentPtr
var param = Params(prerequisiteComponent: prerequisiteComponent)
let fnName {.used.} = n "RemoveTickPrerequisiteComponent"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc removeTickPrerequisiteActor*(self : AActorPtr;
prerequisiteActor : AActorPtr): void {.
exportcpp: "$1_".} =
type
Params = object
prerequisiteActor: AActorPtr
var param = Params(prerequisiteActor: prerequisiteActor)
let fnName {.used.} = n "RemoveTickPrerequisiteActor"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc prestreamTextures*(self : AActorPtr; seconds : float32;
bEnableStreaming : bool;
cinematicTextureGroups : int32 = 0'i32): void {.
exportcpp: "$1_".} =
type
Params = object
seconds: float32
bEnableStreaming: bool
cinematicTextureGroups: int32
var param = Params(seconds: seconds,
bEnableStreaming: bEnableStreaming,
cinematicTextureGroups: cinematicTextureGroups)
let fnName {.used.} = n "PrestreamTextures"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc makeNoise*(self : AActorPtr;
loudness : float32 = 1.0'f32;
noiseInstigator : APawnPtr = nil;
noiseLocation : FVector;
maxRange : float32 = 0.0'f32;
tag : FName = makeFName("None")): void {.
exportcpp: "$1_".} =
type
Params = object
loudness: float32
noiseInstigator: APawnPtr
noiseLocation: FVector
maxRange: float32
tag: FName
var param = Params(loudness: loudness,
noiseInstigator: noiseInstigator,
noiseLocation: noiseLocation,
maxRange: maxRange, tag: tag)
let fnName {.used.} = n "MakeNoise"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc teleportTo*(self : AActorPtr; destLocation : FVector;
destRotation : FRotator): bool {.exportcpp: "$1_".} =
type
Params = object
destLocation: FVector
destRotation: FRotator
returnValue: bool
var param = Params(destLocation: destLocation,
destRotation: destRotation)
let fnName {.used.} = n "K2_TeleportTo"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc setActorTransform*(self : AActorPtr;
newTransform : var FTransform;
bSweep : bool;
sweepHitResult : var FHitResult;
bTeleport : bool): bool {.exportcpp: "$1_".} =
type
Params = object
newTransform: FTransform
bSweep: bool
sweepHitResult: FHitResult
bTeleport: bool
returnValue: bool
var param = Params(newTransform: newTransform, bSweep: bSweep,
sweepHitResult: sweepHitResult,
bTeleport: bTeleport)
let fnName {.used.} = n "K2_SetActorTransform"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
newTransform = param.newTransform
sweepHitResult = param.sweepHitResult
return param.returnValue
proc setActorRotation*(self : AActorPtr;
newRotation : FRotator;
bTeleportPhysics : bool): bool {.
exportcpp: "$1_".} =
type
Params = object
newRotation: FRotator
bTeleportPhysics: bool
returnValue: bool
var param = Params(newRotation: newRotation,
bTeleportPhysics: bTeleportPhysics)
let fnName {.used.} = n "K2_SetActorRotation"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc setActorRelativeTransform*(self : AActorPtr;
newRelativeTransform : var FTransform;
bSweep : bool;
sweepHitResult : var FHitResult;
bTeleport : bool): void {.
exportcpp: "$1_".} =
type
Params = object
newRelativeTransform: FTransform
bSweep: bool
sweepHitResult: FHitResult
bTeleport: bool
var param = Params(newRelativeTransform: newRelativeTransform,
bSweep: bSweep, sweepHitResult: sweepHitResult,
bTeleport: bTeleport)
let fnName {.used.} = n "K2_SetActorRelativeTransform"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
newRelativeTransform = param.newRelativeTransform
sweepHitResult = param.sweepHitResult
proc setActorRelativeRotation*(self : AActorPtr;
newRelativeRotation : FRotator;
bSweep : bool;
sweepHitResult : var FHitResult;
bTeleport : bool): void {.
exportcpp: "$1_".} =
type
Params = object
newRelativeRotation: FRotator
bSweep: bool
sweepHitResult: FHitResult
bTeleport: bool
var param = Params(newRelativeRotation: newRelativeRotation,
bSweep: bSweep, sweepHitResult: sweepHitResult,
bTeleport: bTeleport)
let fnName {.used.} = n "K2_SetActorRelativeRotation"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
sweepHitResult = param.sweepHitResult
proc setActorRelativeLocation*(self : AActorPtr;
newRelativeLocation : FVector;
bSweep : bool;
sweepHitResult : var FHitResult;
bTeleport : bool): void {.
exportcpp: "$1_".} =
type
Params = object
newRelativeLocation: FVector
bSweep: bool
sweepHitResult: FHitResult
bTeleport: bool
var param = Params(newRelativeLocation: newRelativeLocation,
bSweep: bSweep, sweepHitResult: sweepHitResult,
bTeleport: bTeleport)
let fnName {.used.} = n "K2_SetActorRelativeLocation"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
sweepHitResult = param.sweepHitResult
proc setActorLocationAndRotation*(self : AActorPtr;
newLocation : FVector;
newRotation : FRotator;
bSweep : bool;
sweepHitResult : var FHitResult;
bTeleport : bool): bool {.
exportcpp: "$1_".} =
type
Params = object
newLocation: FVector
newRotation: FRotator
bSweep: bool
sweepHitResult: FHitResult
bTeleport: bool
returnValue: bool
var param = Params(newLocation: newLocation,
newRotation: newRotation, bSweep: bSweep,
sweepHitResult: sweepHitResult,
bTeleport: bTeleport)
let fnName {.used.} = n "K2_SetActorLocationAndRotation"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
sweepHitResult = param.sweepHitResult
return param.returnValue
proc setActorLocation*(self : AActorPtr;
newLocation : FVector; bSweep : bool;
sweepHitResult : var FHitResult;
bTeleport : bool): bool {.exportcpp: "$1_".} =
type
Params = object
newLocation: FVector
bSweep: bool
sweepHitResult: FHitResult
bTeleport: bool
returnValue: bool
var param = Params(newLocation: newLocation, bSweep: bSweep,
sweepHitResult: sweepHitResult,
bTeleport: bTeleport)
let fnName {.used.} = n "K2_SetActorLocation"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
sweepHitResult = param.sweepHitResult
return param.returnValue
proc getComponentsByClass*(self : AActorPtr; componentClass : TSubclassOf[
UActorComponent]): TArray[UActorComponentPtr] {.exportcpp: "$1_".} =
type
Params = object
componentClass: TSubclassOf[UActorComponent]
returnValue: TArray[UActorComponentPtr]
var param = Params(componentClass: componentClass)
let fnName {.used.} = n "K2_GetComponentsByClass"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getActorRotation*(self : AActorPtr): FRotator {.exportcpp: "$1_".} =
type
Params = object
returnValue: FRotator
var param = Params()
let fnName {.used.} = n "K2_GetActorRotation"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getActorLocation*(self : AActorPtr): FVector {.exportcpp: "$1_".} =
type
Params = object
returnValue: FVector
var param = Params()
let fnName {.used.} = n "K2_GetActorLocation"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc detachFromActor*(self : AActorPtr; locationRule : EDetachmentRule = EDetachmentRule.KeepRelative;
rotationRule : EDetachmentRule = EDetachmentRule.KeepRelative;
scaleRule : EDetachmentRule = EDetachmentRule.KeepRelative): void {.
exportcpp: "$1_".} =
type
Params = object
locationRule: EDetachmentRule
rotationRule: EDetachmentRule
scaleRule: EDetachmentRule
var param = Params(locationRule: locationRule,
rotationRule: rotationRule, scaleRule: scaleRule)
let fnName {.used.} = n "K2_DetachFromActor"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc destroyActor*(self : AActorPtr): void {.exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "K2_DestroyActor"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc attachToComponent*(self : AActorPtr;
parent : USceneComponentPtr;
socketName : FName;
locationRule : EAttachmentRule;
rotationRule : EAttachmentRule;
scaleRule : EAttachmentRule;
bWeldSimulatedBodies : bool): void {.
exportcpp: "$1_".} =
type
Params = object
parent: USceneComponentPtr
socketName: FName
locationRule: EAttachmentRule
rotationRule: EAttachmentRule
scaleRule: EAttachmentRule
bWeldSimulatedBodies: bool
var param = Params(parent: parent, socketName: socketName,
locationRule: locationRule,
rotationRule: rotationRule,
scaleRule: scaleRule,
bWeldSimulatedBodies: bWeldSimulatedBodies)
let fnName {.used.} = n "K2_AttachToComponent"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc attachToActor*(self : AActorPtr;
parentActor : AActorPtr;
socketName : FName;
locationRule : EAttachmentRule;
rotationRule : EAttachmentRule;
scaleRule : EAttachmentRule;
bWeldSimulatedBodies : bool): void {.
exportcpp: "$1_".} =
type
Params = object
parentActor: AActorPtr
socketName: FName
locationRule: EAttachmentRule
rotationRule: EAttachmentRule
scaleRule: EAttachmentRule
bWeldSimulatedBodies: bool
var param = Params(parentActor: parentActor,
socketName: socketName,
locationRule: locationRule,
rotationRule: rotationRule,
scaleRule: scaleRule,
bWeldSimulatedBodies: bWeldSimulatedBodies)
let fnName {.used.} = n "K2_AttachToActor"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc attachRootComponentToActor*(self : AActorPtr;
inParentActor : AActorPtr;
inSocketName : FName = makeFName("None");
attachLocationType : EAttachLocation = EAttachLocation.KeepRelativeOffset;
bWeldSimulatedBodies : bool = true): void {.
exportcpp: "$1_".} =
type
Params = object
inParentActor: AActorPtr
inSocketName: FName
attachLocationType: EAttachLocation
bWeldSimulatedBodies: bool
var param = Params(inParentActor: inParentActor,
inSocketName: inSocketName,
attachLocationType: attachLocationType,
bWeldSimulatedBodies: bWeldSimulatedBodies)
let fnName {.used.} = n "K2_AttachRootComponentToActor"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc attachRootComponentTo*(self : AActorPtr;
inParent : USceneComponentPtr;
inSocketName : FName = makeFName("None");
attachLocationType : EAttachLocation = EAttachLocation.KeepRelativeOffset;
bWeldSimulatedBodies : bool = true): void {.
exportcpp: "$1_".} =
type
Params = object
inParent: USceneComponentPtr
inSocketName: FName
attachLocationType: EAttachLocation
bWeldSimulatedBodies: bool
var param = Params(inParent: inParent, inSocketName: inSocketName,
attachLocationType: attachLocationType,
bWeldSimulatedBodies: bWeldSimulatedBodies)
let fnName {.used.} = n "K2_AttachRootComponentTo"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc addActorWorldTransformKeepScale*(self : AActorPtr;
deltaTransform : var FTransform;
bSweep : bool;
sweepHitResult : var FHitResult;
bTeleport : bool): void {.
exportcpp: "$1_".} =
type
Params = object
deltaTransform: FTransform
bSweep: bool
sweepHitResult: FHitResult
bTeleport: bool
var param = Params(deltaTransform: deltaTransform, bSweep: bSweep,
sweepHitResult: sweepHitResult,
bTeleport: bTeleport)
let fnName {.used.} = n "K2_AddActorWorldTransformKeepScale"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
deltaTransform = param.deltaTransform
sweepHitResult = param.sweepHitResult
proc addActorWorldTransform*(self : AActorPtr;
deltaTransform : var FTransform;
bSweep : bool;
sweepHitResult : var FHitResult;
bTeleport : bool): void {.
exportcpp: "$1_".} =
type
Params = object
deltaTransform: FTransform
bSweep: bool
sweepHitResult: FHitResult
bTeleport: bool
var param = Params(deltaTransform: deltaTransform, bSweep: bSweep,
sweepHitResult: sweepHitResult,
bTeleport: bTeleport)
let fnName {.used.} = n "K2_AddActorWorldTransform"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
deltaTransform = param.deltaTransform
sweepHitResult = param.sweepHitResult
proc addActorWorldRotation*(self : AActorPtr;
deltaRotation : FRotator;
bSweep : bool;
sweepHitResult : var FHitResult;
bTeleport : bool): void {.exportcpp: "$1_".} =
type
Params = object
deltaRotation: FRotator
bSweep: bool
sweepHitResult: FHitResult
bTeleport: bool
var param = Params(deltaRotation: deltaRotation, bSweep: bSweep,
sweepHitResult: sweepHitResult,
bTeleport: bTeleport)
let fnName {.used.} = n "K2_AddActorWorldRotation"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
sweepHitResult = param.sweepHitResult
proc addActorWorldOffset*(self : AActorPtr;
deltaLocation : FVector;
bSweep : bool;
sweepHitResult : var FHitResult;
bTeleport : bool): void {.exportcpp: "$1_".} =
type
Params = object
deltaLocation: FVector
bSweep: bool
sweepHitResult: FHitResult
bTeleport: bool
var param = Params(deltaLocation: deltaLocation, bSweep: bSweep,
sweepHitResult: sweepHitResult,
bTeleport: bTeleport)
let fnName {.used.} = n "K2_AddActorWorldOffset"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
sweepHitResult = param.sweepHitResult
proc addActorLocalTransform*(self : AActorPtr;
newTransform : var FTransform;
bSweep : bool;
sweepHitResult : var FHitResult;
bTeleport : bool): void {.
exportcpp: "$1_".} =
type
Params = object
newTransform: FTransform
bSweep: bool
sweepHitResult: FHitResult
bTeleport: bool
var param = Params(newTransform: newTransform, bSweep: bSweep,
sweepHitResult: sweepHitResult,
bTeleport: bTeleport)
let fnName {.used.} = n "K2_AddActorLocalTransform"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
newTransform = param.newTransform
sweepHitResult = param.sweepHitResult
proc addActorLocalRotation*(self : AActorPtr;
deltaRotation : FRotator;
bSweep : bool;
sweepHitResult : var FHitResult;
bTeleport : bool): void {.exportcpp: "$1_".} =
type
Params = object
deltaRotation: FRotator
bSweep: bool
sweepHitResult: FHitResult
bTeleport: bool
var param = Params(deltaRotation: deltaRotation, bSweep: bSweep,
sweepHitResult: sweepHitResult,
bTeleport: bTeleport)
let fnName {.used.} = n "K2_AddActorLocalRotation"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
sweepHitResult = param.sweepHitResult
proc addActorLocalOffset*(self : AActorPtr;
deltaLocation : FVector;
bSweep : bool;
sweepHitResult : var FHitResult;
bTeleport : bool): void {.exportcpp: "$1_".} =
type
Params = object
deltaLocation: FVector
bSweep: bool
sweepHitResult: FHitResult
bTeleport: bool
var param = Params(deltaLocation: deltaLocation, bSweep: bSweep,
sweepHitResult: sweepHitResult,
bTeleport: bTeleport)
let fnName {.used.} = n "K2_AddActorLocalOffset"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
sweepHitResult = param.sweepHitResult
proc isTemporarilyHiddenInEditor*(self : AActorPtr;
bIncludeParent : bool = false): bool {.
exportcpp: "$1_".} =
type
Params = object
bIncludeParent: bool
returnValue: bool
var param = Params(bIncludeParent: bIncludeParent)
let fnName {.used.} = n "IsTemporarilyHiddenInEditor"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isSelectable*(self : AActorPtr): bool {.exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsSelectable"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isOverlappingActor*(self : AActorPtr; other : AActorPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
other: AActorPtr
returnValue: bool
var param = Params(other: other)
let fnName {.used.} = n "IsOverlappingActor"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isHiddenEdAtStartup*(self : AActorPtr): bool {.exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsHiddenEdAtStartup"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isHiddenEd*(self : AActorPtr): bool {.exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsHiddenEd"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isEditable*(self : AActorPtr): bool {.exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsEditable"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isChildActor*(self : AActorPtr): bool {.exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsChildActor"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isActorTickEnabled*(self : AActorPtr): bool {.exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsActorTickEnabled"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isActorBeingDestroyed*(self : AActorPtr): bool {.exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsActorBeingDestroyed"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc hasAuthority*(self : AActorPtr): bool {.exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "HasAuthority"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getVerticalDistanceTo*(self : AActorPtr;
otherActor : AActorPtr): float32 {.
exportcpp: "$1_".} =
type
Params = object
otherActor: AActorPtr
returnValue: float32
var param = Params(otherActor: otherActor)
let fnName {.used.} = n "GetVerticalDistanceTo"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getVelocity*(self : AActorPtr): FVector {.exportcpp: "$1_".} =
type
Params = object
returnValue: FVector
var param = Params()
let fnName {.used.} = n "GetVelocity"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getTransform*(self : AActorPtr): FTransform {.exportcpp: "$1_".} =
type
Params = object
returnValue: FTransform
var param = Params()
let fnName {.used.} = n "GetTransform"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getTickableWhenPaused*(self : AActorPtr): bool {.exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "GetTickableWhenPaused"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getSquaredHorizontalDistanceTo*(self : AActorPtr;
otherActor : AActorPtr): float32 {.
exportcpp: "$1_".} =
type
Params = object
otherActor: AActorPtr
returnValue: float32
var param = Params(otherActor: otherActor)
let fnName {.used.} = n "GetSquaredHorizontalDistanceTo"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getSquaredDistanceTo*(self : AActorPtr;
otherActor : AActorPtr): float32 {.
exportcpp: "$1_".} =
type
Params = object
otherActor: AActorPtr
returnValue: float32
var param = Params(otherActor: otherActor)
let fnName {.used.} = n "GetSquaredDistanceTo"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getRemoteRole*(self : AActorPtr): ENetRole {.exportcpp: "$1_".} =
type
Params = object
returnValue: ENetRole
var param = Params()
let fnName {.used.} = n "GetRemoteRole"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getRayTracingGroupId*(self : AActorPtr): int32 {.exportcpp: "$1_".} =
type
Params = object
returnValue: int32
var param = Params()
let fnName {.used.} = n "GetRayTracingGroupId"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getParentComponent*(self : AActorPtr): UChildActorComponentPtr {.
exportcpp: "$1_".} =
type
Params = object
returnValue: UChildActorComponentPtr
var param = Params()
let fnName {.used.} = n "GetParentComponent"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getParentActor*(self : AActorPtr): AActorPtr {.exportcpp: "$1_".} =
type
Params = object
returnValue: AActorPtr
var param = Params()
let fnName {.used.} = n "GetParentActor"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getOwner*(self : AActorPtr): AActorPtr {.exportcpp: "$1_".} =
type
Params = object
returnValue: AActorPtr
var param = Params()
let fnName {.used.} = n "GetOwner"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getOverlappingComponents*(self : AActorPtr;
overlappingComponents : var TArray[UPrimitiveComponentPtr]): void {.
exportcpp: "$1_".} =
type
Params = object
overlappingComponents: TArray[UPrimitiveComponentPtr]
var param = Params(overlappingComponents: overlappingComponents)
let fnName {.used.} = n "GetOverlappingComponents"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
overlappingComponents = param.overlappingComponents
proc getOverlappingActors*(self : AActorPtr;
overlappingActors : var TArray[AActorPtr];
classFilter : TSubclassOf[AActor]): void {.
exportcpp: "$1_".} =
type
Params = object
overlappingActors: TArray[AActorPtr]
classFilter: TSubclassOf[AActor]
var param = Params(overlappingActors: overlappingActors,
classFilter: classFilter)
let fnName {.used.} = n "GetOverlappingActors"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
overlappingActors = param.overlappingActors
proc getLocalRole*(self : AActorPtr): ENetRole {.exportcpp: "$1_".} =
type
Params = object
returnValue: ENetRole
var param = Params()
let fnName {.used.} = n "GetLocalRole"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getLifeSpan*(self : AActorPtr): float32 {.exportcpp: "$1_".} =
type
Params = object
returnValue: float32
var param = Params()
let fnName {.used.} = n "GetLifeSpan"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getLevelTransform*(self : AActorPtr): FTransform {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FTransform
var param = Params()
let fnName {.used.} = n "GetLevelTransform"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getLevel*(self : AActorPtr): ULevelPtr {.exportcpp: "$1_".} =
type
Params = object
returnValue: ULevelPtr
var param = Params()
let fnName {.used.} = n "GetLevel"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getInstigatorController*(self : AActorPtr): AControllerPtr {.
exportcpp: "$1_".} =
type
Params = object
returnValue: AControllerPtr
var param = Params()
let fnName {.used.} = n "GetInstigatorController"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getInstigator*(self : AActorPtr): APawnPtr {.exportcpp: "$1_".} =
type
Params = object
returnValue: APawnPtr
var param = Params()
let fnName {.used.} = n "GetInstigator"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getInputVectorAxisValue*(self : AActorPtr;
inputAxisKey : FKey): FVector {.
exportcpp: "$1_".} =
type
Params = object
inputAxisKey: FKey
returnValue: FVector
var param = Params(inputAxisKey: inputAxisKey)
let fnName {.used.} = n "GetInputVectorAxisValue"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getInputAxisValue*(self : AActorPtr;
inputAxisName : FName): float32 {.
exportcpp: "$1_".} =
type
Params = object
inputAxisName: FName
returnValue: float32
var param = Params(inputAxisName: inputAxisName)
let fnName {.used.} = n "GetInputAxisValue"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getInputAxisKeyValue*(self : AActorPtr;
inputAxisKey : FKey): float32 {.
exportcpp: "$1_".} =
type
Params = object
inputAxisKey: FKey
returnValue: float32
var param = Params(inputAxisKey: inputAxisKey)
let fnName {.used.} = n "GetInputAxisKeyValue"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getHorizontalDotProductTo*(self : AActorPtr;
otherActor : AActorPtr): float32 {.
exportcpp: "$1_".} =
type
Params = object
otherActor: AActorPtr
returnValue: float32
var param = Params(otherActor: otherActor)
let fnName {.used.} = n "GetHorizontalDotProductTo"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getHorizontalDistanceTo*(self : AActorPtr;
otherActor : AActorPtr): float32 {.
exportcpp: "$1_".} =
type
Params = object
otherActor: AActorPtr
returnValue: float32
var param = Params(otherActor: otherActor)
let fnName {.used.} = n "GetHorizontalDistanceTo"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getGameTimeSinceCreation*(self : AActorPtr): float32 {.
exportcpp: "$1_".} =
type
Params = object
returnValue: float32
var param = Params()
let fnName {.used.} = n "GetGameTimeSinceCreation"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getFolderPath*(self : AActorPtr): FName {.exportcpp: "$1_".} =
type
Params = object
returnValue: FName
var param = Params()
let fnName {.used.} = n "GetFolderPath"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getDotProductTo*(self : AActorPtr;
otherActor : AActorPtr): float32 {.
exportcpp: "$1_".} =
type
Params = object
otherActor: AActorPtr
returnValue: float32
var param = Params(otherActor: otherActor)
let fnName {.used.} = n "GetDotProductTo"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getDistanceTo*(self : AActorPtr; otherActor : AActorPtr): float32 {.
exportcpp: "$1_".} =
type
Params = object
otherActor: AActorPtr
returnValue: float32
var param = Params(otherActor: otherActor)
let fnName {.used.} = n "GetDistanceTo"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getDefaultActorLabel*(self : AActorPtr): FString {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FString
var param = Params()
let fnName {.used.} = n "GetDefaultActorLabel"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getComponentsByTag*(self : AActorPtr; componentClass : TSubclassOf[
UActorComponent]; tag : FName): TArray[UActorComponentPtr] {.
exportcpp: "$1_".} =
type
Params = object
componentClass: TSubclassOf[UActorComponent]
tag: FName
returnValue: TArray[UActorComponentPtr]
var param = Params(componentClass: componentClass, tag: tag)
let fnName {.used.} = n "GetComponentsByTag"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getComponentsByInterface*(self : AActorPtr;
`interface` : TSubclassOf[UInterface]): TArray[
UActorComponentPtr] {.exportcpp: "$1_".} =
type
Params = object
`interface`: TSubclassOf[UInterface]
returnValue: TArray[UActorComponentPtr]
var param = Params(`interface`: `interface`)
let fnName {.used.} = n "GetComponentsByInterface"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getComponentByClass*(self : AActorPtr; componentClass : TSubclassOf[
UActorComponent]): UActorComponentPtr {.exportcpp: "$1_".} =
type
Params = object
componentClass: TSubclassOf[UActorComponent]
returnValue: UActorComponentPtr
var param = Params(componentClass: componentClass)
let fnName {.used.} = n "GetComponentByClass"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getAttachParentSocketName*(self : AActorPtr): FName {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FName
var param = Params()
let fnName {.used.} = n "GetAttachParentSocketName"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getAttachParentActor*(self : AActorPtr): AActorPtr {.
exportcpp: "$1_".} =
type
Params = object
returnValue: AActorPtr
var param = Params()
let fnName {.used.} = n "GetAttachParentActor"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getAttachedActors*(self : AActorPtr;
outActors : var TArray[AActorPtr];
bResetArray : bool = true;
bRecursivelyIncludeAttachedActors : bool = false): void {.
exportcpp: "$1_".} =
type
Params = object
outActors: TArray[AActorPtr]
bResetArray: bool
bRecursivelyIncludeAttachedActors: bool
var param = Params(outActors: outActors, bResetArray: bResetArray, bRecursivelyIncludeAttachedActors: bRecursivelyIncludeAttachedActors)
let fnName {.used.} = n "GetAttachedActors"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
outActors = param.outActors
proc getAllChildActors*(self : AActorPtr;
childActors : var TArray[AActorPtr];
bIncludeDescendants : bool = true): void {.
exportcpp: "$1_".} =
type
Params = object
childActors: TArray[AActorPtr]
bIncludeDescendants: bool
var param = Params(childActors: childActors,
bIncludeDescendants: bIncludeDescendants)
let fnName {.used.} = n "GetAllChildActors"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
childActors = param.childActors
proc getActorUpVector*(self : AActorPtr): FVector {.exportcpp: "$1_".} =
type
Params = object
returnValue: FVector
var param = Params()
let fnName {.used.} = n "GetActorUpVector"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getActorTimeDilation*(self : AActorPtr): float32 {.
exportcpp: "$1_".} =
type
Params = object
returnValue: float32
var param = Params()
let fnName {.used.} = n "GetActorTimeDilation"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getActorTickInterval*(self : AActorPtr): float32 {.
exportcpp: "$1_".} =
type
Params = object
returnValue: float32
var param = Params()
let fnName {.used.} = n "GetActorTickInterval"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getActorScale3D*(self : AActorPtr): FVector {.exportcpp: "$1_".} =
type
Params = object
returnValue: FVector
var param = Params()
let fnName {.used.} = n "GetActorScale3D"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getActorRightVector*(self : AActorPtr): FVector {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FVector
var param = Params()
let fnName {.used.} = n "GetActorRightVector"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getActorRelativeScale3D*(self : AActorPtr): FVector {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FVector
var param = Params()
let fnName {.used.} = n "GetActorRelativeScale3D"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getActorLabel*(self : AActorPtr;
bCreateIfNone : bool = true): FString {.
exportcpp: "$1_".} =
type
Params = object
bCreateIfNone: bool
returnValue: FString
var param = Params(bCreateIfNone: bCreateIfNone)
let fnName {.used.} = n "GetActorLabel"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getActorForwardVector*(self : AActorPtr): FVector {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FVector
var param = Params()
let fnName {.used.} = n "GetActorForwardVector"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getActorEyesViewPoint*(self : AActorPtr;
outLocation : var FVector;
outRotation : var FRotator): void {.
exportcpp: "$1_".} =
type
Params = object
outLocation: FVector
outRotation: FRotator
var param = Params(outLocation: outLocation,
outRotation: outRotation)
let fnName {.used.} = n "GetActorEyesViewPoint"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
outLocation = param.outLocation
outRotation = param.outRotation
proc getActorEnableCollision*(self : AActorPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "GetActorEnableCollision"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getActorBounds*(self : AActorPtr;
bOnlyCollidingComponents : bool;
origin : var FVector;
boxExtent : var FVector;
bIncludeFromChildActors : bool = false): void {.
exportcpp: "$1_".} =
type
Params = object
bOnlyCollidingComponents: bool
origin: FVector
boxExtent: FVector
bIncludeFromChildActors: bool
var param = Params(bOnlyCollidingComponents: bOnlyCollidingComponents,
origin: origin, boxExtent: boxExtent, bIncludeFromChildActors: bIncludeFromChildActors)
let fnName {.used.} = n "GetActorBounds"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
origin = param.origin
boxExtent = param.boxExtent
proc forceNetUpdate*(self : AActorPtr): void {.exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "ForceNetUpdate"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc flushNetDormancy*(self : AActorPtr): void {.exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "FlushNetDormancy"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc finishAddComponent*(self : AActorPtr;
component : UActorComponentPtr;
bManualAttachment : bool;
relativeTransform : var FTransform): void {.
exportcpp: "$1_".} =
type
Params = object
component: UActorComponentPtr
bManualAttachment: bool
relativeTransform: FTransform
var param = Params(component: component,
bManualAttachment: bManualAttachment,
relativeTransform: relativeTransform)
let fnName {.used.} = n "FinishAddComponent"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
relativeTransform = param.relativeTransform
proc enableInput*(self : AActorPtr;
playerController : APlayerControllerPtr): void {.
exportcpp: "$1_".} =
type
Params = object
playerController: APlayerControllerPtr
var param = Params(playerController: playerController)
let fnName {.used.} = n "EnableInput"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc disableInput*(self : AActorPtr;
playerController : APlayerControllerPtr): void {.
exportcpp: "$1_".} =
type
Params = object
playerController: APlayerControllerPtr
var param = Params(playerController: playerController)
let fnName {.used.} = n "DisableInput"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc detachRootComponentFromParent*(self : AActorPtr;
bMaintainWorldPosition : bool = true): void {.exportcpp: "$1_".} =
type
Params = object
bMaintainWorldPosition: bool
var param = Params(bMaintainWorldPosition: bMaintainWorldPosition)
let fnName {.used.} = n "DetachRootComponentFromParent"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc addTickPrerequisiteComponent*(self : AActorPtr;
prerequisiteComponent : UActorComponentPtr): void {.
exportcpp: "$1_".} =
type
Params = object
prerequisiteComponent: UActorComponentPtr
var param = Params(prerequisiteComponent: prerequisiteComponent)
let fnName {.used.} = n "AddTickPrerequisiteComponent"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc addTickPrerequisiteActor*(self : AActorPtr;
prerequisiteActor : AActorPtr): void {.
exportcpp: "$1_".} =
type
Params = object
prerequisiteActor: AActorPtr
var param = Params(prerequisiteActor: prerequisiteActor)
let fnName {.used.} = n "AddTickPrerequisiteActor"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc addComponentByClass*(self : AActorPtr;
class : TSubclassOf[UActorComponent];
bManualAttachment : bool;
relativeTransform : var FTransform;
bDeferredFinish : bool): UActorComponentPtr {.
exportcpp: "$1_".} =
type
Params = object
class: TSubclassOf[UActorComponent]
bManualAttachment: bool
relativeTransform: FTransform
bDeferredFinish: bool
returnValue: UActorComponentPtr
var param = Params(class: class,
bManualAttachment: bManualAttachment,
relativeTransform: relativeTransform,
bDeferredFinish: bDeferredFinish)
let fnName {.used.} = n "AddComponentByClass"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
relativeTransform = param.relativeTransform
return param.returnValue
proc addComponent*(self : AActorPtr; templateName : FName;
bManualAttachment : bool;
relativeTransform : var FTransform;
componentTemplateContext : UObjectPtr;
bDeferredFinish : bool = false): UActorComponentPtr {.
exportcpp: "$1_".} =
type
Params = object
templateName: FName
bManualAttachment: bool
relativeTransform: FTransform
componentTemplateContext: UObjectPtr
bDeferredFinish: bool
returnValue: UActorComponentPtr
var param = Params(templateName: templateName,
bManualAttachment: bManualAttachment,
relativeTransform: relativeTransform, componentTemplateContext: componentTemplateContext,
bDeferredFinish: bDeferredFinish)
let fnName {.used.} = n "AddComponent"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
relativeTransform = param.relativeTransform
return param.returnValue
proc actorHasTag*(self : AActorPtr; tag : FName): bool {.
exportcpp: "$1_".} =
type
Params = object
tag: FName
returnValue: bool
var param = Params(tag: tag)
let fnName {.used.} = n "ActorHasTag"
let fn {.used.} = getClassByName("Actor").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc keepAActor(fake : AActor) {.exportcpp.} =
discard
proc keepUBlueprintFunctionLibrary(fake : UBlueprintFunctionLibrary) {.
exportcpp.} =
discard
proc `object`*(obj : UAssetExportTaskPtr): UObjectPtr {.exportcpp.} =
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"Object")
getPropertyValuePtr[UObjectPtr](prop, obj)[]
proc `object=`*(obj : UAssetExportTaskPtr; val : UObjectPtr) =
var value : UObjectPtr = val
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"Object")
setPropertyValuePtr[UObjectPtr](prop, obj, value.addr)
proc `set object`*(obj : UAssetExportTaskPtr;
val : UObjectPtr) {.exportcpp.} =
var value : UObjectPtr = val
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"Object")
setPropertyValuePtr[UObjectPtr](prop, obj, value.addr)
proc `exporter`*(obj : UAssetExportTaskPtr): UExporterPtr {.exportcpp.} =
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"Exporter")
getPropertyValuePtr[UExporterPtr](prop, obj)[]
proc `exporter=`*(obj : UAssetExportTaskPtr;
val : UExporterPtr) =
var value : UExporterPtr = val
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"Exporter")
setPropertyValuePtr[UExporterPtr](prop, obj, value.addr)
proc `set exporter`*(obj : UAssetExportTaskPtr;
val : UExporterPtr) {.exportcpp.} =
var value : UExporterPtr = val
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"Exporter")
setPropertyValuePtr[UExporterPtr](prop, obj, value.addr)
proc `filename`*(obj : UAssetExportTaskPtr): FString {.exportcpp.} =
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"Filename")
getPropertyValuePtr[FString](prop, obj)[]
proc `filename=`*(obj : UAssetExportTaskPtr; val : FString) =
var value : FString = val
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"Filename")
setPropertyValuePtr[FString](prop, obj, value.addr)
proc `set filename`*(obj : UAssetExportTaskPtr; val : FString) {.
exportcpp.} =
var value : FString = val
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"Filename")
setPropertyValuePtr[FString](prop, obj, value.addr)
proc `bSelected`*(obj : UAssetExportTaskPtr): bool {.exportcpp.} =
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"bSelected")
getValueFromBoolProp(prop, obj)
proc `bSelected=`*(obj : UAssetExportTaskPtr; val : bool) =
var value : bool = val
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"bSelected")
setValueInBoolProp(prop, obj, value)
proc `set bSelected`*(obj : UAssetExportTaskPtr; val : bool) {.
exportcpp.} =
var value : bool = val
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"bSelected")
setValueInBoolProp(prop, obj, value)
proc `bReplaceIdentical`*(obj : UAssetExportTaskPtr): bool {.exportcpp.} =
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"bReplaceIdentical")
getValueFromBoolProp(prop, obj)
proc `bReplaceIdentical=`*(obj : UAssetExportTaskPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"bReplaceIdentical")
setValueInBoolProp(prop, obj, value)
proc `set bReplaceIdentical`*(obj : UAssetExportTaskPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"bReplaceIdentical")
setValueInBoolProp(prop, obj, value)
proc `bPrompt`*(obj : UAssetExportTaskPtr): bool {.exportcpp.} =
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"bPrompt")
getValueFromBoolProp(prop, obj)
proc `bPrompt=`*(obj : UAssetExportTaskPtr; val : bool) =
var value : bool = val
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"bPrompt")
setValueInBoolProp(prop, obj, value)
proc `set bPrompt`*(obj : UAssetExportTaskPtr; val : bool) {.
exportcpp.} =
var value : bool = val
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"bPrompt")
setValueInBoolProp(prop, obj, value)
proc `bAutomated`*(obj : UAssetExportTaskPtr): bool {.exportcpp.} =
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"bAutomated")
getValueFromBoolProp(prop, obj)
proc `bAutomated=`*(obj : UAssetExportTaskPtr; val : bool) =
var value : bool = val
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"bAutomated")
setValueInBoolProp(prop, obj, value)
proc `set bAutomated`*(obj : UAssetExportTaskPtr; val : bool) {.
exportcpp.} =
var value : bool = val
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"bAutomated")
setValueInBoolProp(prop, obj, value)
proc `bUseFileArchive`*(obj : UAssetExportTaskPtr): bool {.exportcpp.} =
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"bUseFileArchive")
getValueFromBoolProp(prop, obj)
proc `bUseFileArchive=`*(obj : UAssetExportTaskPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"bUseFileArchive")
setValueInBoolProp(prop, obj, value)
proc `set bUseFileArchive`*(obj : UAssetExportTaskPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"bUseFileArchive")
setValueInBoolProp(prop, obj, value)
proc `bWriteEmptyFiles`*(obj : UAssetExportTaskPtr): bool {.exportcpp.} =
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"bWriteEmptyFiles")
getValueFromBoolProp(prop, obj)
proc `bWriteEmptyFiles=`*(obj : UAssetExportTaskPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"bWriteEmptyFiles")
setValueInBoolProp(prop, obj, value)
proc `set bWriteEmptyFiles`*(obj : UAssetExportTaskPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"bWriteEmptyFiles")
setValueInBoolProp(prop, obj, value)
proc `ignoreObjectList`*(obj : UAssetExportTaskPtr): var TArray[
UObjectPtr] {.exportcpp.} =
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"IgnoreObjectList")
getPropertyValuePtr[TArray[UObjectPtr]](prop, obj)[]
proc `ignoreObjectList=`*(obj : UAssetExportTaskPtr;
val : TArray[UObjectPtr]) =
var value : TArray[UObjectPtr] = val
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"IgnoreObjectList")
setPropertyValuePtr[TArray[UObjectPtr]](prop, obj, value.addr)
proc `set ignoreObjectList`*(obj : UAssetExportTaskPtr;
val : TArray[UObjectPtr]) {.exportcpp.} =
var value : TArray[UObjectPtr] = val
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"IgnoreObjectList")
setPropertyValuePtr[TArray[UObjectPtr]](prop, obj, value.addr)
proc `options`*(obj : UAssetExportTaskPtr): UObjectPtr {.exportcpp.} =
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"Options")
getPropertyValuePtr[UObjectPtr](prop, obj)[]
proc `options=`*(obj : UAssetExportTaskPtr; val : UObjectPtr) =
var value : UObjectPtr = val
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"Options")
setPropertyValuePtr[UObjectPtr](prop, obj, value.addr)
proc `set options`*(obj : UAssetExportTaskPtr;
val : UObjectPtr) {.exportcpp.} =
var value : UObjectPtr = val
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"Options")
setPropertyValuePtr[UObjectPtr](prop, obj, value.addr)
proc `errors`*(obj : UAssetExportTaskPtr): var TArray[FString] {.
exportcpp.} =
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"Errors")
getPropertyValuePtr[TArray[FString]](prop, obj)[]
proc `errors=`*(obj : UAssetExportTaskPtr;
val : TArray[FString]) =
var value : TArray[FString] = val
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"Errors")
setPropertyValuePtr[TArray[FString]](prop, obj, value.addr)
proc `set errors`*(obj : UAssetExportTaskPtr;
val : TArray[FString]) {.exportcpp.} =
var value : TArray[FString] = val
let prop = getClassByName("AssetExportTask").getFPropertyByName(
"Errors")
setPropertyValuePtr[TArray[FString]](prop, obj, value.addr)
proc keepUAssetExportTask(fake : UAssetExportTask) {.exportcpp.} =
discard
proc keepUDataAsset(fake : UDataAsset) {.exportcpp.} =
discard
proc `componentTags`*(obj : UActorComponentPtr): var TArray[FName] {.
exportcpp.} =
let prop = getClassByName("ActorComponent").getFPropertyByName(
"ComponentTags")
getPropertyValuePtr[TArray[FName]](prop, obj)[]
proc `componentTags=`*(obj : UActorComponentPtr;
val : TArray[FName]) =
var value : TArray[FName] = val
let prop = getClassByName("ActorComponent").getFPropertyByName(
"ComponentTags")
setPropertyValuePtr[TArray[FName]](prop, obj, value.addr)
proc `set componentTags`*(obj : UActorComponentPtr;
val : TArray[FName]) {.exportcpp.} =
var value : TArray[FName] = val
let prop = getClassByName("ActorComponent").getFPropertyByName(
"ComponentTags")
setPropertyValuePtr[TArray[FName]](prop, obj, value.addr)
proc `bReplicateUsingRegisteredSubObjectList`*(obj : UActorComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("ActorComponent").getFPropertyByName(
"bReplicateUsingRegisteredSubObjectList")
getValueFromBoolProp(prop, obj)
proc `bReplicateUsingRegisteredSubObjectList=`*(
obj : UActorComponentPtr; val : bool) =
var value : bool = val
let prop = getClassByName("ActorComponent").getFPropertyByName(
"bReplicateUsingRegisteredSubObjectList")
setValueInBoolProp(prop, obj, value)
proc `set bReplicateUsingRegisteredSubObjectList`*(
obj : UActorComponentPtr; val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("ActorComponent").getFPropertyByName(
"bReplicateUsingRegisteredSubObjectList")
setValueInBoolProp(prop, obj, value)
proc `bReplicates`*(obj : UActorComponentPtr): bool {.exportcpp.} =
let prop = getClassByName("ActorComponent").getFPropertyByName(
"bReplicates")
getValueFromBoolProp(prop, obj)
proc `bReplicates=`*(obj : UActorComponentPtr; val : bool) =
var value : bool = val
let prop = getClassByName("ActorComponent").getFPropertyByName(
"bReplicates")
setValueInBoolProp(prop, obj, value)
proc `set bReplicates`*(obj : UActorComponentPtr; val : bool) {.
exportcpp.} =
var value : bool = val
let prop = getClassByName("ActorComponent").getFPropertyByName(
"bReplicates")
setValueInBoolProp(prop, obj, value)
proc `bAutoActivate`*(obj : UActorComponentPtr): bool {.exportcpp.} =
let prop = getClassByName("ActorComponent").getFPropertyByName(
"bAutoActivate")
getValueFromBoolProp(prop, obj)
proc `bAutoActivate=`*(obj : UActorComponentPtr; val : bool) =
var value : bool = val
let prop = getClassByName("ActorComponent").getFPropertyByName(
"bAutoActivate")
setValueInBoolProp(prop, obj, value)
proc `set bAutoActivate`*(obj : UActorComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("ActorComponent").getFPropertyByName(
"bAutoActivate")
setValueInBoolProp(prop, obj, value)
proc `bIsEditorOnly`*(obj : UActorComponentPtr): bool {.exportcpp.} =
let prop = getClassByName("ActorComponent").getFPropertyByName(
"bIsEditorOnly")
getValueFromBoolProp(prop, obj)
proc `bIsEditorOnly=`*(obj : UActorComponentPtr; val : bool) =
var value : bool = val
let prop = getClassByName("ActorComponent").getFPropertyByName(
"bIsEditorOnly")
setValueInBoolProp(prop, obj, value)
proc `set bIsEditorOnly`*(obj : UActorComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("ActorComponent").getFPropertyByName(
"bIsEditorOnly")
setValueInBoolProp(prop, obj, value)
proc toggleActive*(self : UActorComponentPtr): void {.exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "ToggleActive"
let fn {.used.} = getClassByName("ActorComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setTickGroup*(self : UActorComponentPtr;
newTickGroup : ETickingGroup): void {.
exportcpp: "$1_".} =
type
Params = object
newTickGroup: ETickingGroup
var param = Params(newTickGroup: newTickGroup)
let fnName {.used.} = n "SetTickGroup"
let fn {.used.} = getClassByName("ActorComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setTickableWhenPaused*(self : UActorComponentPtr;
bTickableWhenPaused : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bTickableWhenPaused: bool
var param = Params(bTickableWhenPaused: bTickableWhenPaused)
let fnName {.used.} = n "SetTickableWhenPaused"
let fn {.used.} = getClassByName("ActorComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setIsReplicated*(self : UActorComponentPtr;
shouldReplicate : bool): void {.exportcpp: "$1_".} =
type
Params = object
shouldReplicate: bool
var param = Params(shouldReplicate: shouldReplicate)
let fnName {.used.} = n "SetIsReplicated"
let fn {.used.} = getClassByName("ActorComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setComponentTickIntervalAndCooldown*(self : UActorComponentPtr;
tickInterval : float32): void {.exportcpp: "$1_".} =
type
Params = object
tickInterval: float32
var param = Params(tickInterval: tickInterval)
let fnName {.used.} = n "SetComponentTickIntervalAndCooldown"
let fn {.used.} = getClassByName("ActorComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setComponentTickInterval*(self : UActorComponentPtr;
tickInterval : float32): void {.
exportcpp: "$1_".} =
type
Params = object
tickInterval: float32
var param = Params(tickInterval: tickInterval)
let fnName {.used.} = n "SetComponentTickInterval"
let fn {.used.} = getClassByName("ActorComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setComponentTickEnabled*(self : UActorComponentPtr;
bEnabled : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bEnabled: bool
var param = Params(bEnabled: bEnabled)
let fnName {.used.} = n "SetComponentTickEnabled"
let fn {.used.} = getClassByName("ActorComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setAutoActivate*(self : UActorComponentPtr;
bNewAutoActivate : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bNewAutoActivate: bool
var param = Params(bNewAutoActivate: bNewAutoActivate)
let fnName {.used.} = n "SetAutoActivate"
let fn {.used.} = getClassByName("ActorComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setActive*(self : UActorComponentPtr; bNewActive : bool;
bReset : bool = false): void {.exportcpp: "$1_".} =
type
Params = object
bNewActive: bool
bReset: bool
var param = Params(bNewActive: bNewActive, bReset: bReset)
let fnName {.used.} = n "SetActive"
let fn {.used.} = getClassByName("ActorComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc removeTickPrerequisiteComponent*(self : UActorComponentPtr;
prerequisiteComponent : UActorComponentPtr): void {.
exportcpp: "$1_".} =
type
Params = object
prerequisiteComponent: UActorComponentPtr
var param = Params(prerequisiteComponent: prerequisiteComponent)
let fnName {.used.} = n "RemoveTickPrerequisiteComponent"
let fn {.used.} = getClassByName("ActorComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc removeTickPrerequisiteActor*(self : UActorComponentPtr;
prerequisiteActor : AActorPtr): void {.
exportcpp: "$1_".} =
type
Params = object
prerequisiteActor: AActorPtr
var param = Params(prerequisiteActor: prerequisiteActor)
let fnName {.used.} = n "RemoveTickPrerequisiteActor"
let fn {.used.} = getClassByName("ActorComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc destroyComponent*(self : UActorComponentPtr;
`object` : UObjectPtr): void {.exportcpp: "$1_".} =
type
Params = object
`object`: UObjectPtr
var param = Params(`object`: `object`)
let fnName {.used.} = n "K2_DestroyComponent"
let fn {.used.} = getClassByName("ActorComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc isComponentTickEnabled*(self : UActorComponentPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsComponentTickEnabled"
let fn {.used.} = getClassByName("ActorComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isBeingDestroyed*(self : UActorComponentPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsBeingDestroyed"
let fn {.used.} = getClassByName("ActorComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isActive*(self : UActorComponentPtr): bool {.exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsActive"
let fn {.used.} = getClassByName("ActorComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getOwner*(self : UActorComponentPtr): AActorPtr {.
exportcpp: "$1_".} =
type
Params = object
returnValue: AActorPtr
var param = Params()
let fnName {.used.} = n "GetOwner"
let fn {.used.} = getClassByName("ActorComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getComponentTickInterval*(self : UActorComponentPtr): float32 {.
exportcpp: "$1_".} =
type
Params = object
returnValue: float32
var param = Params()
let fnName {.used.} = n "GetComponentTickInterval"
let fn {.used.} = getClassByName("ActorComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc deactivate*(self : UActorComponentPtr): void {.exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "Deactivate"
let fn {.used.} = getClassByName("ActorComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc componentHasTag*(self : UActorComponentPtr; tag : FName): bool {.
exportcpp: "$1_".} =
type
Params = object
tag: FName
returnValue: bool
var param = Params(tag: tag)
let fnName {.used.} = n "ComponentHasTag"
let fn {.used.} = getClassByName("ActorComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc addTickPrerequisiteComponent*(self : UActorComponentPtr;
prerequisiteComponent : UActorComponentPtr): void {.
exportcpp: "$1_".} =
type
Params = object
prerequisiteComponent: UActorComponentPtr
var param = Params(prerequisiteComponent: prerequisiteComponent)
let fnName {.used.} = n "AddTickPrerequisiteComponent"
let fn {.used.} = getClassByName("ActorComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc addTickPrerequisiteActor*(self : UActorComponentPtr;
prerequisiteActor : AActorPtr): void {.
exportcpp: "$1_".} =
type
Params = object
prerequisiteActor: AActorPtr
var param = Params(prerequisiteActor: prerequisiteActor)
let fnName {.used.} = n "AddTickPrerequisiteActor"
let fn {.used.} = getClassByName("ActorComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc activate*(self : UActorComponentPtr;
bReset : bool = false): void {.exportcpp: "$1_".} =
type
Params = object
bReset: bool
var param = Params(bReset: bReset)
let fnName {.used.} = n "Activate"
let fn {.used.} = getClassByName("ActorComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc keepUActorComponent(fake : UActorComponent) {.exportcpp.} =
discard
converter UActorComponenttoUInterface_AssetUserData*(
self : UActorComponentPtr): UInterface_AssetUserDataPtr =
cast[UInterface_AssetUserDataPtr](self)
proc `relativeLocation`*(obj : USceneComponentPtr): var FVector {.
exportcpp.} =
let prop = getClassByName("SceneComponent").getFPropertyByName(
"RelativeLocation")
getPropertyValuePtr[FVector](prop, obj)[]
proc `relativeLocation=`*(obj : USceneComponentPtr;
val : FVector) =
var value : FVector = val
let prop = getClassByName("SceneComponent").getFPropertyByName(
"RelativeLocation")
setPropertyValuePtr[FVector](prop, obj, value.addr)
proc `set relativeLocation`*(obj : USceneComponentPtr;
val : FVector) {.exportcpp.} =
var value : FVector = val
let prop = getClassByName("SceneComponent").getFPropertyByName(
"RelativeLocation")
setPropertyValuePtr[FVector](prop, obj, value.addr)
proc `relativeRotation`*(obj : USceneComponentPtr): var FRotator {.
exportcpp.} =
let prop = getClassByName("SceneComponent").getFPropertyByName(
"RelativeRotation")
getPropertyValuePtr[FRotator](prop, obj)[]
proc `relativeRotation=`*(obj : USceneComponentPtr;
val : FRotator) =
var value : FRotator = val
let prop = getClassByName("SceneComponent").getFPropertyByName(
"RelativeRotation")
setPropertyValuePtr[FRotator](prop, obj, value.addr)
proc `set relativeRotation`*(obj : USceneComponentPtr;
val : FRotator) {.exportcpp.} =
var value : FRotator = val
let prop = getClassByName("SceneComponent").getFPropertyByName(
"RelativeRotation")
setPropertyValuePtr[FRotator](prop, obj, value.addr)
proc `relativeScale3D`*(obj : USceneComponentPtr): var FVector {.
exportcpp.} =
let prop = getClassByName("SceneComponent").getFPropertyByName(
"RelativeScale3D")
getPropertyValuePtr[FVector](prop, obj)[]
proc `relativeScale3D=`*(obj : USceneComponentPtr;
val : FVector) =
var value : FVector = val
let prop = getClassByName("SceneComponent").getFPropertyByName(
"RelativeScale3D")
setPropertyValuePtr[FVector](prop, obj, value.addr)
proc `set relativeScale3D`*(obj : USceneComponentPtr;
val : FVector) {.exportcpp.} =
var value : FVector = val
let prop = getClassByName("SceneComponent").getFPropertyByName(
"RelativeScale3D")
setPropertyValuePtr[FVector](prop, obj, value.addr)
proc `bAbsoluteLocation`*(obj : USceneComponentPtr): bool {.exportcpp.} =
let prop = getClassByName("SceneComponent").getFPropertyByName(
"bAbsoluteLocation")
getValueFromBoolProp(prop, obj)
proc `bAbsoluteLocation=`*(obj : USceneComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SceneComponent").getFPropertyByName(
"bAbsoluteLocation")
setValueInBoolProp(prop, obj, value)
proc `set bAbsoluteLocation`*(obj : USceneComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SceneComponent").getFPropertyByName(
"bAbsoluteLocation")
setValueInBoolProp(prop, obj, value)
proc `bAbsoluteRotation`*(obj : USceneComponentPtr): bool {.exportcpp.} =
let prop = getClassByName("SceneComponent").getFPropertyByName(
"bAbsoluteRotation")
getValueFromBoolProp(prop, obj)
proc `bAbsoluteRotation=`*(obj : USceneComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SceneComponent").getFPropertyByName(
"bAbsoluteRotation")
setValueInBoolProp(prop, obj, value)
proc `set bAbsoluteRotation`*(obj : USceneComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SceneComponent").getFPropertyByName(
"bAbsoluteRotation")
setValueInBoolProp(prop, obj, value)
proc `bAbsoluteScale`*(obj : USceneComponentPtr): bool {.exportcpp.} =
let prop = getClassByName("SceneComponent").getFPropertyByName(
"bAbsoluteScale")
getValueFromBoolProp(prop, obj)
proc `bAbsoluteScale=`*(obj : USceneComponentPtr; val : bool) =
var value : bool = val
let prop = getClassByName("SceneComponent").getFPropertyByName(
"bAbsoluteScale")
setValueInBoolProp(prop, obj, value)
proc `set bAbsoluteScale`*(obj : USceneComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SceneComponent").getFPropertyByName(
"bAbsoluteScale")
setValueInBoolProp(prop, obj, value)
proc `bVisible`*(obj : USceneComponentPtr): bool {.exportcpp.} =
let prop = getClassByName("SceneComponent").getFPropertyByName(
"bVisible")
getValueFromBoolProp(prop, obj)
proc `bVisible=`*(obj : USceneComponentPtr; val : bool) =
var value : bool = val
let prop = getClassByName("SceneComponent").getFPropertyByName(
"bVisible")
setValueInBoolProp(prop, obj, value)
proc `set bVisible`*(obj : USceneComponentPtr; val : bool) {.
exportcpp.} =
var value : bool = val
let prop = getClassByName("SceneComponent").getFPropertyByName(
"bVisible")
setValueInBoolProp(prop, obj, value)
proc `bShouldUpdatePhysicsVolume`*(obj : USceneComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("SceneComponent").getFPropertyByName(
"bShouldUpdatePhysicsVolume")
getValueFromBoolProp(prop, obj)
proc `bShouldUpdatePhysicsVolume=`*(obj : USceneComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SceneComponent").getFPropertyByName(
"bShouldUpdatePhysicsVolume")
setValueInBoolProp(prop, obj, value)
proc `set bShouldUpdatePhysicsVolume`*(obj : USceneComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SceneComponent").getFPropertyByName(
"bShouldUpdatePhysicsVolume")
setValueInBoolProp(prop, obj, value)
proc `bHiddenInGame`*(obj : USceneComponentPtr): bool {.exportcpp.} =
let prop = getClassByName("SceneComponent").getFPropertyByName(
"bHiddenInGame")
getValueFromBoolProp(prop, obj)
proc `bHiddenInGame=`*(obj : USceneComponentPtr; val : bool) =
var value : bool = val
let prop = getClassByName("SceneComponent").getFPropertyByName(
"bHiddenInGame")
setValueInBoolProp(prop, obj, value)
proc `set bHiddenInGame`*(obj : USceneComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SceneComponent").getFPropertyByName(
"bHiddenInGame")
setValueInBoolProp(prop, obj, value)
proc `bUseAttachParentBound`*(obj : USceneComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("SceneComponent").getFPropertyByName(
"bUseAttachParentBound")
getValueFromBoolProp(prop, obj)
proc `bUseAttachParentBound=`*(obj : USceneComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SceneComponent").getFPropertyByName(
"bUseAttachParentBound")
setValueInBoolProp(prop, obj, value)
proc `set bUseAttachParentBound`*(obj : USceneComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SceneComponent").getFPropertyByName(
"bUseAttachParentBound")
setValueInBoolProp(prop, obj, value)
proc `mobility`*(obj : USceneComponentPtr): EComponentMobility {.
exportcpp.} =
let prop = getClassByName("SceneComponent").getFPropertyByName(
"Mobility")
getPropertyValuePtr[EComponentMobility](prop, obj)[]
proc `mobility=`*(obj : USceneComponentPtr;
val : EComponentMobility) =
var value : EComponentMobility = val
let prop = getClassByName("SceneComponent").getFPropertyByName(
"Mobility")
setPropertyValuePtr[EComponentMobility](prop, obj, value.addr)
proc `set mobility`*(obj : USceneComponentPtr;
val : EComponentMobility) {.exportcpp.} =
var value : EComponentMobility = val
let prop = getClassByName("SceneComponent").getFPropertyByName(
"Mobility")
setPropertyValuePtr[EComponentMobility](prop, obj, value.addr)
proc `detailMode`*(obj : USceneComponentPtr): EDetailMode {.exportcpp.} =
let prop = getClassByName("SceneComponent").getFPropertyByName(
"DetailMode")
getPropertyValuePtr[EDetailMode](prop, obj)[]
proc `detailMode=`*(obj : USceneComponentPtr;
val : EDetailMode) =
var value : EDetailMode = val
let prop = getClassByName("SceneComponent").getFPropertyByName(
"DetailMode")
setPropertyValuePtr[EDetailMode](prop, obj, value.addr)
proc `set detailMode`*(obj : USceneComponentPtr;
val : EDetailMode) {.exportcpp.} =
var value : EDetailMode = val
let prop = getClassByName("SceneComponent").getFPropertyByName(
"DetailMode")
setPropertyValuePtr[EDetailMode](prop, obj, value.addr)
proc toggleVisibility*(self : USceneComponentPtr;
bPropagateToChildren : bool = false): void {.
exportcpp: "$1_".} =
type
Params = object
bPropagateToChildren: bool
var param = Params(bPropagateToChildren: bPropagateToChildren)
let fnName {.used.} = n "ToggleVisibility"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setWorldScale3D*(self : USceneComponentPtr;
newScale : FVector): void {.exportcpp: "$1_".} =
type
Params = object
newScale: FVector
var param = Params(newScale: newScale)
let fnName {.used.} = n "SetWorldScale3D"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setVisibility*(self : USceneComponentPtr;
bNewVisibility : bool;
bPropagateToChildren : bool = false): void {.
exportcpp: "$1_".} =
type
Params = object
bNewVisibility: bool
bPropagateToChildren: bool
var param = Params(bNewVisibility: bNewVisibility,
bPropagateToChildren: bPropagateToChildren)
let fnName {.used.} = n "SetVisibility"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setShouldUpdatePhysicsVolume*(self : USceneComponentPtr;
bInShouldUpdatePhysicsVolume : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bInShouldUpdatePhysicsVolume: bool
var param = Params(bInShouldUpdatePhysicsVolume: bInShouldUpdatePhysicsVolume)
let fnName {.used.} = n "SetShouldUpdatePhysicsVolume"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setRelativeScale3D*(self : USceneComponentPtr;
newScale3D : FVector): void {.
exportcpp: "$1_".} =
type
Params = object
newScale3D: FVector
var param = Params(newScale3D: newScale3D)
let fnName {.used.} = n "SetRelativeScale3D"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setMobility*(self : USceneComponentPtr;
newMobility : EComponentMobility): void {.
exportcpp: "$1_".} =
type
Params = object
newMobility: EComponentMobility
var param = Params(newMobility: newMobility)
let fnName {.used.} = n "SetMobility"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setHiddenInGame*(self : USceneComponentPtr;
newHidden : bool;
bPropagateToChildren : bool = false): void {.
exportcpp: "$1_".} =
type
Params = object
newHidden: bool
bPropagateToChildren: bool
var param = Params(newHidden: newHidden,
bPropagateToChildren: bPropagateToChildren)
let fnName {.used.} = n "SetHiddenInGame"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setAbsolute*(self : USceneComponentPtr;
bNewAbsoluteLocation : bool = false;
bNewAbsoluteRotation : bool = false;
bNewAbsoluteScale : bool = false): void {.
exportcpp: "$1_".} =
type
Params = object
bNewAbsoluteLocation: bool
bNewAbsoluteRotation: bool
bNewAbsoluteScale: bool
var param = Params(bNewAbsoluteLocation: bNewAbsoluteLocation,
bNewAbsoluteRotation: bNewAbsoluteRotation,
bNewAbsoluteScale: bNewAbsoluteScale)
let fnName {.used.} = n "SetAbsolute"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc resetRelativeTransform*(self : USceneComponentPtr): void {.
exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "ResetRelativeTransform"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setWorldTransform*(self : USceneComponentPtr;
newTransform : var FTransform;
bSweep : bool;
sweepHitResult : var FHitResult;
bTeleport : bool): void {.exportcpp: "$1_".} =
type
Params = object
newTransform: FTransform
bSweep: bool
sweepHitResult: FHitResult
bTeleport: bool
var param = Params(newTransform: newTransform, bSweep: bSweep,
sweepHitResult: sweepHitResult,
bTeleport: bTeleport)
let fnName {.used.} = n "K2_SetWorldTransform"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
newTransform = param.newTransform
sweepHitResult = param.sweepHitResult
proc setWorldRotation*(self : USceneComponentPtr;
newRotation : FRotator; bSweep : bool;
sweepHitResult : var FHitResult;
bTeleport : bool): void {.exportcpp: "$1_".} =
type
Params = object
newRotation: FRotator
bSweep: bool
sweepHitResult: FHitResult
bTeleport: bool
var param = Params(newRotation: newRotation, bSweep: bSweep,
sweepHitResult: sweepHitResult,
bTeleport: bTeleport)
let fnName {.used.} = n "K2_SetWorldRotation"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
sweepHitResult = param.sweepHitResult
proc setWorldLocationAndRotation*(self : USceneComponentPtr;
newLocation : FVector;
newRotation : FRotator;
bSweep : bool;
sweepHitResult : var FHitResult;
bTeleport : bool): void {.
exportcpp: "$1_".} =
type
Params = object
newLocation: FVector
newRotation: FRotator
bSweep: bool
sweepHitResult: FHitResult
bTeleport: bool
var param = Params(newLocation: newLocation,
newRotation: newRotation, bSweep: bSweep,
sweepHitResult: sweepHitResult,
bTeleport: bTeleport)
let fnName {.used.} = n "K2_SetWorldLocationAndRotation"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
sweepHitResult = param.sweepHitResult
proc setWorldLocation*(self : USceneComponentPtr;
newLocation : FVector; bSweep : bool;
sweepHitResult : var FHitResult;
bTeleport : bool): void {.exportcpp: "$1_".} =
type
Params = object
newLocation: FVector
bSweep: bool
sweepHitResult: FHitResult
bTeleport: bool
var param = Params(newLocation: newLocation, bSweep: bSweep,
sweepHitResult: sweepHitResult,
bTeleport: bTeleport)
let fnName {.used.} = n "K2_SetWorldLocation"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
sweepHitResult = param.sweepHitResult
proc setRelativeTransform*(self : USceneComponentPtr;
newTransform : var FTransform;
bSweep : bool;
sweepHitResult : var FHitResult;
bTeleport : bool): void {.exportcpp: "$1_".} =
type
Params = object
newTransform: FTransform
bSweep: bool
sweepHitResult: FHitResult
bTeleport: bool
var param = Params(newTransform: newTransform, bSweep: bSweep,
sweepHitResult: sweepHitResult,
bTeleport: bTeleport)
let fnName {.used.} = n "K2_SetRelativeTransform"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
newTransform = param.newTransform
sweepHitResult = param.sweepHitResult
proc setRelativeRotation*(self : USceneComponentPtr;
newRotation : FRotator;
bSweep : bool;
sweepHitResult : var FHitResult;
bTeleport : bool): void {.exportcpp: "$1_".} =
type
Params = object
newRotation: FRotator
bSweep: bool
sweepHitResult: FHitResult
bTeleport: bool
var param = Params(newRotation: newRotation, bSweep: bSweep,
sweepHitResult: sweepHitResult,
bTeleport: bTeleport)
let fnName {.used.} = n "K2_SetRelativeRotation"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
sweepHitResult = param.sweepHitResult
proc setRelativeLocationAndRotation*(self : USceneComponentPtr;
newLocation : FVector;
newRotation : FRotator;
bSweep : bool;
sweepHitResult : var FHitResult;
bTeleport : bool): void {.
exportcpp: "$1_".} =
type
Params = object
newLocation: FVector
newRotation: FRotator
bSweep: bool
sweepHitResult: FHitResult
bTeleport: bool
var param = Params(newLocation: newLocation,
newRotation: newRotation, bSweep: bSweep,
sweepHitResult: sweepHitResult,
bTeleport: bTeleport)
let fnName {.used.} = n "K2_SetRelativeLocationAndRotation"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
sweepHitResult = param.sweepHitResult
proc setRelativeLocation*(self : USceneComponentPtr;
newLocation : FVector;
bSweep : bool;
sweepHitResult : var FHitResult;
bTeleport : bool): void {.exportcpp: "$1_".} =
type
Params = object
newLocation: FVector
bSweep: bool
sweepHitResult: FHitResult
bTeleport: bool
var param = Params(newLocation: newLocation, bSweep: bSweep,
sweepHitResult: sweepHitResult,
bTeleport: bTeleport)
let fnName {.used.} = n "K2_SetRelativeLocation"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
sweepHitResult = param.sweepHitResult
proc getComponentToWorld*(self : USceneComponentPtr): FTransform {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FTransform
var param = Params()
let fnName {.used.} = n "K2_GetComponentToWorld"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getComponentScale*(self : USceneComponentPtr): FVector {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FVector
var param = Params()
let fnName {.used.} = n "K2_GetComponentScale"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getComponentRotation*(self : USceneComponentPtr): FRotator {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FRotator
var param = Params()
let fnName {.used.} = n "K2_GetComponentRotation"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getComponentLocation*(self : USceneComponentPtr): FVector {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FVector
var param = Params()
let fnName {.used.} = n "K2_GetComponentLocation"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc detachFromComponent*(self : USceneComponentPtr;
locationRule : EDetachmentRule = EDetachmentRule.KeepRelative;
rotationRule : EDetachmentRule = EDetachmentRule.KeepRelative;
scaleRule : EDetachmentRule = EDetachmentRule.KeepRelative;
bCallModify : bool = true): void {.
exportcpp: "$1_".} =
type
Params = object
locationRule: EDetachmentRule
rotationRule: EDetachmentRule
scaleRule: EDetachmentRule
bCallModify: bool
var param = Params(locationRule: locationRule,
rotationRule: rotationRule,
scaleRule: scaleRule, bCallModify: bCallModify)
let fnName {.used.} = n "K2_DetachFromComponent"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc attachToComponent*(self : USceneComponentPtr;
parent : USceneComponentPtr;
socketName : FName;
locationRule : EAttachmentRule;
rotationRule : EAttachmentRule;
scaleRule : EAttachmentRule;
bWeldSimulatedBodies : bool): bool {.
exportcpp: "$1_".} =
type
Params = object
parent: USceneComponentPtr
socketName: FName
locationRule: EAttachmentRule
rotationRule: EAttachmentRule
scaleRule: EAttachmentRule
bWeldSimulatedBodies: bool
returnValue: bool
var param = Params(parent: parent, socketName: socketName,
locationRule: locationRule,
rotationRule: rotationRule,
scaleRule: scaleRule,
bWeldSimulatedBodies: bWeldSimulatedBodies)
let fnName {.used.} = n "K2_AttachToComponent"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc attachTo*(self : USceneComponentPtr;
inParent : USceneComponentPtr;
inSocketName : FName = makeFName("None");
attachType : EAttachLocation = EAttachLocation.KeepRelativeOffset;
bWeldSimulatedBodies : bool = true): bool {.
exportcpp: "$1_".} =
type
Params = object
inParent: USceneComponentPtr
inSocketName: FName
attachType: EAttachLocation
bWeldSimulatedBodies: bool
returnValue: bool
var param = Params(inParent: inParent, inSocketName: inSocketName,
attachType: attachType,
bWeldSimulatedBodies: bWeldSimulatedBodies)
let fnName {.used.} = n "K2_AttachTo"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc addWorldTransformKeepScale*(self : USceneComponentPtr;
deltaTransform : var FTransform;
bSweep : bool;
sweepHitResult : var FHitResult;
bTeleport : bool): void {.
exportcpp: "$1_".} =
type
Params = object
deltaTransform: FTransform
bSweep: bool
sweepHitResult: FHitResult
bTeleport: bool
var param = Params(deltaTransform: deltaTransform, bSweep: bSweep,
sweepHitResult: sweepHitResult,
bTeleport: bTeleport)
let fnName {.used.} = n "K2_AddWorldTransformKeepScale"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
deltaTransform = param.deltaTransform
sweepHitResult = param.sweepHitResult
proc addWorldTransform*(self : USceneComponentPtr;
deltaTransform : var FTransform;
bSweep : bool;
sweepHitResult : var FHitResult;
bTeleport : bool): void {.exportcpp: "$1_".} =
type
Params = object
deltaTransform: FTransform
bSweep: bool
sweepHitResult: FHitResult
bTeleport: bool
var param = Params(deltaTransform: deltaTransform, bSweep: bSweep,
sweepHitResult: sweepHitResult,
bTeleport: bTeleport)
let fnName {.used.} = n "K2_AddWorldTransform"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
deltaTransform = param.deltaTransform
sweepHitResult = param.sweepHitResult
proc addWorldRotation*(self : USceneComponentPtr;
deltaRotation : FRotator;
bSweep : bool;
sweepHitResult : var FHitResult;
bTeleport : bool): void {.exportcpp: "$1_".} =
type
Params = object
deltaRotation: FRotator
bSweep: bool
sweepHitResult: FHitResult
bTeleport: bool
var param = Params(deltaRotation: deltaRotation, bSweep: bSweep,
sweepHitResult: sweepHitResult,
bTeleport: bTeleport)
let fnName {.used.} = n "K2_AddWorldRotation"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
sweepHitResult = param.sweepHitResult
proc addWorldOffset*(self : USceneComponentPtr;
deltaLocation : FVector; bSweep : bool;
sweepHitResult : var FHitResult;
bTeleport : bool): void {.exportcpp: "$1_".} =
type
Params = object
deltaLocation: FVector
bSweep: bool
sweepHitResult: FHitResult
bTeleport: bool
var param = Params(deltaLocation: deltaLocation, bSweep: bSweep,
sweepHitResult: sweepHitResult,
bTeleport: bTeleport)
let fnName {.used.} = n "K2_AddWorldOffset"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
sweepHitResult = param.sweepHitResult
proc addRelativeRotation*(self : USceneComponentPtr;
deltaRotation : FRotator;
bSweep : bool;
sweepHitResult : var FHitResult;
bTeleport : bool): void {.exportcpp: "$1_".} =
type
Params = object
deltaRotation: FRotator
bSweep: bool
sweepHitResult: FHitResult
bTeleport: bool
var param = Params(deltaRotation: deltaRotation, bSweep: bSweep,
sweepHitResult: sweepHitResult,
bTeleport: bTeleport)
let fnName {.used.} = n "K2_AddRelativeRotation"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
sweepHitResult = param.sweepHitResult
proc addRelativeLocation*(self : USceneComponentPtr;
deltaLocation : FVector;
bSweep : bool;
sweepHitResult : var FHitResult;
bTeleport : bool): void {.exportcpp: "$1_".} =
type
Params = object
deltaLocation: FVector
bSweep: bool
sweepHitResult: FHitResult
bTeleport: bool
var param = Params(deltaLocation: deltaLocation, bSweep: bSweep,
sweepHitResult: sweepHitResult,
bTeleport: bTeleport)
let fnName {.used.} = n "K2_AddRelativeLocation"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
sweepHitResult = param.sweepHitResult
proc addLocalTransform*(self : USceneComponentPtr;
deltaTransform : var FTransform;
bSweep : bool;
sweepHitResult : var FHitResult;
bTeleport : bool): void {.exportcpp: "$1_".} =
type
Params = object
deltaTransform: FTransform
bSweep: bool
sweepHitResult: FHitResult
bTeleport: bool
var param = Params(deltaTransform: deltaTransform, bSweep: bSweep,
sweepHitResult: sweepHitResult,
bTeleport: bTeleport)
let fnName {.used.} = n "K2_AddLocalTransform"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
deltaTransform = param.deltaTransform
sweepHitResult = param.sweepHitResult
proc addLocalRotation*(self : USceneComponentPtr;
deltaRotation : FRotator;
bSweep : bool;
sweepHitResult : var FHitResult;
bTeleport : bool): void {.exportcpp: "$1_".} =
type
Params = object
deltaRotation: FRotator
bSweep: bool
sweepHitResult: FHitResult
bTeleport: bool
var param = Params(deltaRotation: deltaRotation, bSweep: bSweep,
sweepHitResult: sweepHitResult,
bTeleport: bTeleport)
let fnName {.used.} = n "K2_AddLocalRotation"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
sweepHitResult = param.sweepHitResult
proc addLocalOffset*(self : USceneComponentPtr;
deltaLocation : FVector; bSweep : bool;
sweepHitResult : var FHitResult;
bTeleport : bool): void {.exportcpp: "$1_".} =
type
Params = object
deltaLocation: FVector
bSweep: bool
sweepHitResult: FHitResult
bTeleport: bool
var param = Params(deltaLocation: deltaLocation, bSweep: bSweep,
sweepHitResult: sweepHitResult,
bTeleport: bTeleport)
let fnName {.used.} = n "K2_AddLocalOffset"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
sweepHitResult = param.sweepHitResult
proc isVisible*(self : USceneComponentPtr): bool {.exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsVisible"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isSimulatingPhysics*(self : USceneComponentPtr;
boneName : FName = makeFName("None")): bool {.
exportcpp: "$1_".} =
type
Params = object
boneName: FName
returnValue: bool
var param = Params(boneName: boneName)
let fnName {.used.} = n "IsSimulatingPhysics"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isAnySimulatingPhysics*(self : USceneComponentPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsAnySimulatingPhysics"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getUpVector*(self : USceneComponentPtr): FVector {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FVector
var param = Params()
let fnName {.used.} = n "GetUpVector"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getSocketTransform*(self : USceneComponentPtr;
inSocketName : FName;
transformSpace : ERelativeTransformSpace = ERelativeTransformSpace.RTS_World): FTransform {.
exportcpp: "$1_".} =
type
Params = object
inSocketName: FName
transformSpace: ERelativeTransformSpace
returnValue: FTransform
var param = Params(inSocketName: inSocketName,
transformSpace: transformSpace)
let fnName {.used.} = n "GetSocketTransform"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getSocketRotation*(self : USceneComponentPtr;
inSocketName : FName): FRotator {.
exportcpp: "$1_".} =
type
Params = object
inSocketName: FName
returnValue: FRotator
var param = Params(inSocketName: inSocketName)
let fnName {.used.} = n "GetSocketRotation"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getSocketQuaternion*(self : USceneComponentPtr;
inSocketName : FName): FQuat {.
exportcpp: "$1_".} =
type
Params = object
inSocketName: FName
returnValue: FQuat
var param = Params(inSocketName: inSocketName)
let fnName {.used.} = n "GetSocketQuaternion"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getSocketLocation*(self : USceneComponentPtr;
inSocketName : FName): FVector {.
exportcpp: "$1_".} =
type
Params = object
inSocketName: FName
returnValue: FVector
var param = Params(inSocketName: inSocketName)
let fnName {.used.} = n "GetSocketLocation"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getShouldUpdatePhysicsVolume*(self : USceneComponentPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "GetShouldUpdatePhysicsVolume"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getRightVector*(self : USceneComponentPtr): FVector {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FVector
var param = Params()
let fnName {.used.} = n "GetRightVector"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getRelativeTransform*(self : USceneComponentPtr): FTransform {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FTransform
var param = Params()
let fnName {.used.} = n "GetRelativeTransform"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getPhysicsVolume*(self : USceneComponentPtr): APhysicsVolumePtr {.
exportcpp: "$1_".} =
type
Params = object
returnValue: APhysicsVolumePtr
var param = Params()
let fnName {.used.} = n "GetPhysicsVolume"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getParentComponents*(self : USceneComponentPtr;
parents : var TArray[USceneComponentPtr]): void {.
exportcpp: "$1_".} =
type
Params = object
parents: TArray[USceneComponentPtr]
var param = Params(parents: parents)
let fnName {.used.} = n "GetParentComponents"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
parents = param.parents
proc getNumChildrenComponents*(self : USceneComponentPtr): int32 {.
exportcpp: "$1_".} =
type
Params = object
returnValue: int32
var param = Params()
let fnName {.used.} = n "GetNumChildrenComponents"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getForwardVector*(self : USceneComponentPtr): FVector {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FVector
var param = Params()
let fnName {.used.} = n "GetForwardVector"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getComponentVelocity*(self : USceneComponentPtr): FVector {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FVector
var param = Params()
let fnName {.used.} = n "GetComponentVelocity"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getChildrenComponents*(self : USceneComponentPtr;
bIncludeAllDescendants : bool;
children : var TArray[USceneComponentPtr]): void {.
exportcpp: "$1_".} =
type
Params = object
bIncludeAllDescendants: bool
children: TArray[USceneComponentPtr]
var param = Params(bIncludeAllDescendants: bIncludeAllDescendants,
children: children)
let fnName {.used.} = n "GetChildrenComponents"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
children = param.children
proc getChildComponent*(self : USceneComponentPtr;
childIndex : int32): USceneComponentPtr {.
exportcpp: "$1_".} =
type
Params = object
childIndex: int32
returnValue: USceneComponentPtr
var param = Params(childIndex: childIndex)
let fnName {.used.} = n "GetChildComponent"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getAttachSocketName*(self : USceneComponentPtr): FName {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FName
var param = Params()
let fnName {.used.} = n "GetAttachSocketName"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getAttachParent*(self : USceneComponentPtr): USceneComponentPtr {.
exportcpp: "$1_".} =
type
Params = object
returnValue: USceneComponentPtr
var param = Params()
let fnName {.used.} = n "GetAttachParent"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getAllSocketNames*(self : USceneComponentPtr): TArray[FName] {.
exportcpp: "$1_".} =
type
Params = object
returnValue: TArray[FName]
var param = Params()
let fnName {.used.} = n "GetAllSocketNames"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc doesSocketExist*(self : USceneComponentPtr;
inSocketName : FName): bool {.exportcpp: "$1_".} =
type
Params = object
inSocketName: FName
returnValue: bool
var param = Params(inSocketName: inSocketName)
let fnName {.used.} = n "DoesSocketExist"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc detachFromParent*(self : USceneComponentPtr;
bMaintainWorldPosition : bool = false;
bCallModify : bool = true): void {.
exportcpp: "$1_".} =
type
Params = object
bMaintainWorldPosition: bool
bCallModify: bool
var param = Params(bMaintainWorldPosition: bMaintainWorldPosition,
bCallModify: bCallModify)
let fnName {.used.} = n "DetachFromParent"
let fn {.used.} = getClassByName("SceneComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc keepUSceneComponent(fake : USceneComponent) {.exportcpp.} =
discard
proc `minDrawDistance`*(obj : UPrimitiveComponentPtr): float32 {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"MinDrawDistance")
getPropertyValuePtr[float32](prop, obj)[]
proc `minDrawDistance=`*(obj : UPrimitiveComponentPtr;
val : float32) =
var value : float32 = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"MinDrawDistance")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set minDrawDistance`*(obj : UPrimitiveComponentPtr;
val : float32) {.exportcpp.} =
var value : float32 = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"MinDrawDistance")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `lDMaxDrawDistance`*(obj : UPrimitiveComponentPtr): float32 {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"LDMaxDrawDistance")
getPropertyValuePtr[float32](prop, obj)[]
proc `lDMaxDrawDistance=`*(obj : UPrimitiveComponentPtr;
val : float32) =
var value : float32 = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"LDMaxDrawDistance")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set lDMaxDrawDistance`*(obj : UPrimitiveComponentPtr;
val : float32) {.exportcpp.} =
var value : float32 = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"LDMaxDrawDistance")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `cachedMaxDrawDistance`*(obj : UPrimitiveComponentPtr): float32 {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"CachedMaxDrawDistance")
getPropertyValuePtr[float32](prop, obj)[]
proc `cachedMaxDrawDistance=`*(obj : UPrimitiveComponentPtr;
val : float32) =
var value : float32 = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"CachedMaxDrawDistance")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set cachedMaxDrawDistance`*(obj : UPrimitiveComponentPtr;
val : float32) {.exportcpp.} =
var value : float32 = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"CachedMaxDrawDistance")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `indirectLightingCacheQuality`*(obj : UPrimitiveComponentPtr): EIndirectLightingCacheQuality {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"IndirectLightingCacheQuality")
getPropertyValuePtr[EIndirectLightingCacheQuality](prop, obj)[]
proc `indirectLightingCacheQuality=`*(obj : UPrimitiveComponentPtr;
val : EIndirectLightingCacheQuality) =
var value : EIndirectLightingCacheQuality = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"IndirectLightingCacheQuality")
setPropertyValuePtr[EIndirectLightingCacheQuality](prop, obj, value.addr)
proc `set indirectLightingCacheQuality`*(obj : UPrimitiveComponentPtr;
val : EIndirectLightingCacheQuality) {.exportcpp.} =
var value : EIndirectLightingCacheQuality = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"IndirectLightingCacheQuality")
setPropertyValuePtr[EIndirectLightingCacheQuality](prop, obj, value.addr)
proc `lightmapType`*(obj : UPrimitiveComponentPtr): ELightmapType {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"LightmapType")
getPropertyValuePtr[ELightmapType](prop, obj)[]
proc `lightmapType=`*(obj : UPrimitiveComponentPtr;
val : ELightmapType) =
var value : ELightmapType = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"LightmapType")
setPropertyValuePtr[ELightmapType](prop, obj, value.addr)
proc `set lightmapType`*(obj : UPrimitiveComponentPtr;
val : ELightmapType) {.exportcpp.} =
var value : ELightmapType = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"LightmapType")
setPropertyValuePtr[ELightmapType](prop, obj, value.addr)
proc `bEnableAutoLODGeneration`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bEnableAutoLODGeneration")
getValueFromBoolProp(prop, obj)
proc `bEnableAutoLODGeneration=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bEnableAutoLODGeneration")
setValueInBoolProp(prop, obj, value)
proc `set bEnableAutoLODGeneration`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bEnableAutoLODGeneration")
setValueInBoolProp(prop, obj, value)
proc `excludeForSpecificHLODLevels`*(obj : UPrimitiveComponentPtr): var TArray[
int32] {.exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"ExcludeForSpecificHLODLevels")
getPropertyValuePtr[TArray[int32]](prop, obj)[]
proc `excludeForSpecificHLODLevels=`*(obj : UPrimitiveComponentPtr;
val : TArray[int32]) =
var value : TArray[int32] = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"ExcludeForSpecificHLODLevels")
setPropertyValuePtr[TArray[int32]](prop, obj, value.addr)
proc `set excludeForSpecificHLODLevels`*(obj : UPrimitiveComponentPtr;
val : TArray[int32]) {.exportcpp.} =
var value : TArray[int32] = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"ExcludeForSpecificHLODLevels")
setPropertyValuePtr[TArray[int32]](prop, obj, value.addr)
proc `hLODBatchingPolicy`*(obj : UPrimitiveComponentPtr): EHLODBatchingPolicy {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"HLODBatchingPolicy")
getPropertyValuePtr[EHLODBatchingPolicy](prop, obj)[]
proc `hLODBatchingPolicy=`*(obj : UPrimitiveComponentPtr;
val : EHLODBatchingPolicy) =
var value : EHLODBatchingPolicy = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"HLODBatchingPolicy")
setPropertyValuePtr[EHLODBatchingPolicy](prop, obj, value.addr)
proc `set hLODBatchingPolicy`*(obj : UPrimitiveComponentPtr;
val : EHLODBatchingPolicy) {.exportcpp.} =
var value : EHLODBatchingPolicy = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"HLODBatchingPolicy")
setPropertyValuePtr[EHLODBatchingPolicy](prop, obj, value.addr)
proc `bNeverDistanceCull`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bNeverDistanceCull")
getValueFromBoolProp(prop, obj)
proc `bNeverDistanceCull=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bNeverDistanceCull")
setValueInBoolProp(prop, obj, value)
proc `set bNeverDistanceCull`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bNeverDistanceCull")
setValueInBoolProp(prop, obj, value)
proc `bAlwaysCreatePhysicsState`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bAlwaysCreatePhysicsState")
getValueFromBoolProp(prop, obj)
proc `bAlwaysCreatePhysicsState=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bAlwaysCreatePhysicsState")
setValueInBoolProp(prop, obj, value)
proc `set bAlwaysCreatePhysicsState`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bAlwaysCreatePhysicsState")
setValueInBoolProp(prop, obj, value)
proc `bGenerateOverlapEvents`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bGenerateOverlapEvents")
getValueFromBoolProp(prop, obj)
proc `bGenerateOverlapEvents=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bGenerateOverlapEvents")
setValueInBoolProp(prop, obj, value)
proc `set bGenerateOverlapEvents`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bGenerateOverlapEvents")
setValueInBoolProp(prop, obj, value)
proc `bMultiBodyOverlap`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bMultiBodyOverlap")
getValueFromBoolProp(prop, obj)
proc `bMultiBodyOverlap=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bMultiBodyOverlap")
setValueInBoolProp(prop, obj, value)
proc `set bMultiBodyOverlap`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bMultiBodyOverlap")
setValueInBoolProp(prop, obj, value)
proc `bTraceComplexOnMove`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bTraceComplexOnMove")
getValueFromBoolProp(prop, obj)
proc `bTraceComplexOnMove=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bTraceComplexOnMove")
setValueInBoolProp(prop, obj, value)
proc `set bTraceComplexOnMove`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bTraceComplexOnMove")
setValueInBoolProp(prop, obj, value)
proc `bReturnMaterialOnMove`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bReturnMaterialOnMove")
getValueFromBoolProp(prop, obj)
proc `bReturnMaterialOnMove=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bReturnMaterialOnMove")
setValueInBoolProp(prop, obj, value)
proc `set bReturnMaterialOnMove`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bReturnMaterialOnMove")
setValueInBoolProp(prop, obj, value)
proc `bAllowCullDistanceVolume`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bAllowCullDistanceVolume")
getValueFromBoolProp(prop, obj)
proc `bAllowCullDistanceVolume=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bAllowCullDistanceVolume")
setValueInBoolProp(prop, obj, value)
proc `set bAllowCullDistanceVolume`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bAllowCullDistanceVolume")
setValueInBoolProp(prop, obj, value)
proc `bVisibleInReflectionCaptures`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bVisibleInReflectionCaptures")
getValueFromBoolProp(prop, obj)
proc `bVisibleInReflectionCaptures=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bVisibleInReflectionCaptures")
setValueInBoolProp(prop, obj, value)
proc `set bVisibleInReflectionCaptures`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bVisibleInReflectionCaptures")
setValueInBoolProp(prop, obj, value)
proc `bVisibleInRealTimeSkyCaptures`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bVisibleInRealTimeSkyCaptures")
getValueFromBoolProp(prop, obj)
proc `bVisibleInRealTimeSkyCaptures=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bVisibleInRealTimeSkyCaptures")
setValueInBoolProp(prop, obj, value)
proc `set bVisibleInRealTimeSkyCaptures`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bVisibleInRealTimeSkyCaptures")
setValueInBoolProp(prop, obj, value)
proc `bVisibleInRayTracing`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bVisibleInRayTracing")
getValueFromBoolProp(prop, obj)
proc `bVisibleInRayTracing=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bVisibleInRayTracing")
setValueInBoolProp(prop, obj, value)
proc `set bVisibleInRayTracing`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bVisibleInRayTracing")
setValueInBoolProp(prop, obj, value)
proc `bRenderInMainPass`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bRenderInMainPass")
getValueFromBoolProp(prop, obj)
proc `bRenderInMainPass=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bRenderInMainPass")
setValueInBoolProp(prop, obj, value)
proc `set bRenderInMainPass`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bRenderInMainPass")
setValueInBoolProp(prop, obj, value)
proc `bRenderInDepthPass`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bRenderInDepthPass")
getValueFromBoolProp(prop, obj)
proc `bRenderInDepthPass=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bRenderInDepthPass")
setValueInBoolProp(prop, obj, value)
proc `set bRenderInDepthPass`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bRenderInDepthPass")
setValueInBoolProp(prop, obj, value)
proc `bReceivesDecals`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bReceivesDecals")
getValueFromBoolProp(prop, obj)
proc `bReceivesDecals=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bReceivesDecals")
setValueInBoolProp(prop, obj, value)
proc `set bReceivesDecals`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bReceivesDecals")
setValueInBoolProp(prop, obj, value)
proc `bOwnerNoSee`*(obj : UPrimitiveComponentPtr): bool {.exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bOwnerNoSee")
getValueFromBoolProp(prop, obj)
proc `bOwnerNoSee=`*(obj : UPrimitiveComponentPtr; val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bOwnerNoSee")
setValueInBoolProp(prop, obj, value)
proc `set bOwnerNoSee`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bOwnerNoSee")
setValueInBoolProp(prop, obj, value)
proc `bOnlyOwnerSee`*(obj : UPrimitiveComponentPtr): bool {.exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bOnlyOwnerSee")
getValueFromBoolProp(prop, obj)
proc `bOnlyOwnerSee=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bOnlyOwnerSee")
setValueInBoolProp(prop, obj, value)
proc `set bOnlyOwnerSee`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bOnlyOwnerSee")
setValueInBoolProp(prop, obj, value)
proc `bTreatAsBackgroundForOcclusion`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bTreatAsBackgroundForOcclusion")
getValueFromBoolProp(prop, obj)
proc `bTreatAsBackgroundForOcclusion=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bTreatAsBackgroundForOcclusion")
setValueInBoolProp(prop, obj, value)
proc `set bTreatAsBackgroundForOcclusion`*(
obj : UPrimitiveComponentPtr; val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bTreatAsBackgroundForOcclusion")
setValueInBoolProp(prop, obj, value)
proc `bUseAsOccluder`*(obj : UPrimitiveComponentPtr): bool {.exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bUseAsOccluder")
getValueFromBoolProp(prop, obj)
proc `bUseAsOccluder=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bUseAsOccluder")
setValueInBoolProp(prop, obj, value)
proc `set bUseAsOccluder`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bUseAsOccluder")
setValueInBoolProp(prop, obj, value)
proc `bForceMipStreaming`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bForceMipStreaming")
getValueFromBoolProp(prop, obj)
proc `bForceMipStreaming=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bForceMipStreaming")
setValueInBoolProp(prop, obj, value)
proc `set bForceMipStreaming`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bForceMipStreaming")
setValueInBoolProp(prop, obj, value)
proc `castShadow`*(obj : UPrimitiveComponentPtr): uint8 {.exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"CastShadow")
getPropertyValuePtr[uint8](prop, obj)[]
proc `castShadow=`*(obj : UPrimitiveComponentPtr; val : uint8) =
var value : uint8 = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"CastShadow")
setPropertyValuePtr[uint8](prop, obj, value.addr)
proc `set castShadow`*(obj : UPrimitiveComponentPtr;
val : uint8) {.exportcpp.} =
var value : uint8 = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"CastShadow")
setPropertyValuePtr[uint8](prop, obj, value.addr)
proc `bEmissiveLightSource`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bEmissiveLightSource")
getValueFromBoolProp(prop, obj)
proc `bEmissiveLightSource=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bEmissiveLightSource")
setValueInBoolProp(prop, obj, value)
proc `set bEmissiveLightSource`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bEmissiveLightSource")
setValueInBoolProp(prop, obj, value)
proc `bAffectDynamicIndirectLighting`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bAffectDynamicIndirectLighting")
getValueFromBoolProp(prop, obj)
proc `bAffectDynamicIndirectLighting=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bAffectDynamicIndirectLighting")
setValueInBoolProp(prop, obj, value)
proc `set bAffectDynamicIndirectLighting`*(
obj : UPrimitiveComponentPtr; val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bAffectDynamicIndirectLighting")
setValueInBoolProp(prop, obj, value)
proc `bAffectIndirectLightingWhileHidden`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bAffectIndirectLightingWhileHidden")
getValueFromBoolProp(prop, obj)
proc `bAffectIndirectLightingWhileHidden=`*(
obj : UPrimitiveComponentPtr; val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bAffectIndirectLightingWhileHidden")
setValueInBoolProp(prop, obj, value)
proc `set bAffectIndirectLightingWhileHidden`*(
obj : UPrimitiveComponentPtr; val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bAffectIndirectLightingWhileHidden")
setValueInBoolProp(prop, obj, value)
proc `bAffectDistanceFieldLighting`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bAffectDistanceFieldLighting")
getValueFromBoolProp(prop, obj)
proc `bAffectDistanceFieldLighting=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bAffectDistanceFieldLighting")
setValueInBoolProp(prop, obj, value)
proc `set bAffectDistanceFieldLighting`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bAffectDistanceFieldLighting")
setValueInBoolProp(prop, obj, value)
proc `bCastDynamicShadow`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bCastDynamicShadow")
getValueFromBoolProp(prop, obj)
proc `bCastDynamicShadow=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bCastDynamicShadow")
setValueInBoolProp(prop, obj, value)
proc `set bCastDynamicShadow`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bCastDynamicShadow")
setValueInBoolProp(prop, obj, value)
proc `bCastStaticShadow`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bCastStaticShadow")
getValueFromBoolProp(prop, obj)
proc `bCastStaticShadow=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bCastStaticShadow")
setValueInBoolProp(prop, obj, value)
proc `set bCastStaticShadow`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bCastStaticShadow")
setValueInBoolProp(prop, obj, value)
proc `bCastVolumetricTranslucentShadow`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bCastVolumetricTranslucentShadow")
getValueFromBoolProp(prop, obj)
proc `bCastVolumetricTranslucentShadow=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bCastVolumetricTranslucentShadow")
setValueInBoolProp(prop, obj, value)
proc `set bCastVolumetricTranslucentShadow`*(
obj : UPrimitiveComponentPtr; val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bCastVolumetricTranslucentShadow")
setValueInBoolProp(prop, obj, value)
proc `bCastContactShadow`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bCastContactShadow")
getValueFromBoolProp(prop, obj)
proc `bCastContactShadow=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bCastContactShadow")
setValueInBoolProp(prop, obj, value)
proc `set bCastContactShadow`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bCastContactShadow")
setValueInBoolProp(prop, obj, value)
proc `bSelfShadowOnly`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bSelfShadowOnly")
getValueFromBoolProp(prop, obj)
proc `bSelfShadowOnly=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bSelfShadowOnly")
setValueInBoolProp(prop, obj, value)
proc `set bSelfShadowOnly`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bSelfShadowOnly")
setValueInBoolProp(prop, obj, value)
proc `bCastFarShadow`*(obj : UPrimitiveComponentPtr): bool {.exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bCastFarShadow")
getValueFromBoolProp(prop, obj)
proc `bCastFarShadow=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bCastFarShadow")
setValueInBoolProp(prop, obj, value)
proc `set bCastFarShadow`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bCastFarShadow")
setValueInBoolProp(prop, obj, value)
proc `bCastInsetShadow`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bCastInsetShadow")
getValueFromBoolProp(prop, obj)
proc `bCastInsetShadow=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bCastInsetShadow")
setValueInBoolProp(prop, obj, value)
proc `set bCastInsetShadow`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bCastInsetShadow")
setValueInBoolProp(prop, obj, value)
proc `bCastCinematicShadow`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bCastCinematicShadow")
getValueFromBoolProp(prop, obj)
proc `bCastCinematicShadow=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bCastCinematicShadow")
setValueInBoolProp(prop, obj, value)
proc `set bCastCinematicShadow`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bCastCinematicShadow")
setValueInBoolProp(prop, obj, value)
proc `bCastHiddenShadow`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bCastHiddenShadow")
getValueFromBoolProp(prop, obj)
proc `bCastHiddenShadow=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bCastHiddenShadow")
setValueInBoolProp(prop, obj, value)
proc `set bCastHiddenShadow`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bCastHiddenShadow")
setValueInBoolProp(prop, obj, value)
proc `bCastShadowAsTwoSided`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bCastShadowAsTwoSided")
getValueFromBoolProp(prop, obj)
proc `bCastShadowAsTwoSided=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bCastShadowAsTwoSided")
setValueInBoolProp(prop, obj, value)
proc `set bCastShadowAsTwoSided`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bCastShadowAsTwoSided")
setValueInBoolProp(prop, obj, value)
proc `bLightAttachmentsAsGroup`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bLightAttachmentsAsGroup")
getValueFromBoolProp(prop, obj)
proc `bLightAttachmentsAsGroup=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bLightAttachmentsAsGroup")
setValueInBoolProp(prop, obj, value)
proc `set bLightAttachmentsAsGroup`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bLightAttachmentsAsGroup")
setValueInBoolProp(prop, obj, value)
proc `bExcludeFromLightAttachmentGroup`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bExcludeFromLightAttachmentGroup")
getValueFromBoolProp(prop, obj)
proc `bExcludeFromLightAttachmentGroup=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bExcludeFromLightAttachmentGroup")
setValueInBoolProp(prop, obj, value)
proc `set bExcludeFromLightAttachmentGroup`*(
obj : UPrimitiveComponentPtr; val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bExcludeFromLightAttachmentGroup")
setValueInBoolProp(prop, obj, value)
proc `bReceiveMobileCSMShadows`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bReceiveMobileCSMShadows")
getValueFromBoolProp(prop, obj)
proc `bReceiveMobileCSMShadows=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bReceiveMobileCSMShadows")
setValueInBoolProp(prop, obj, value)
proc `set bReceiveMobileCSMShadows`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bReceiveMobileCSMShadows")
setValueInBoolProp(prop, obj, value)
proc `bSingleSampleShadowFromStationaryLights`*(
obj : UPrimitiveComponentPtr): bool {.exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bSingleSampleShadowFromStationaryLights")
getValueFromBoolProp(prop, obj)
proc `bSingleSampleShadowFromStationaryLights=`*(
obj : UPrimitiveComponentPtr; val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bSingleSampleShadowFromStationaryLights")
setValueInBoolProp(prop, obj, value)
proc `set bSingleSampleShadowFromStationaryLights`*(
obj : UPrimitiveComponentPtr; val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bSingleSampleShadowFromStationaryLights")
setValueInBoolProp(prop, obj, value)
proc `bIgnoreRadialImpulse`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bIgnoreRadialImpulse")
getValueFromBoolProp(prop, obj)
proc `bIgnoreRadialImpulse=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bIgnoreRadialImpulse")
setValueInBoolProp(prop, obj, value)
proc `set bIgnoreRadialImpulse`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bIgnoreRadialImpulse")
setValueInBoolProp(prop, obj, value)
proc `bIgnoreRadialForce`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bIgnoreRadialForce")
getValueFromBoolProp(prop, obj)
proc `bIgnoreRadialForce=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bIgnoreRadialForce")
setValueInBoolProp(prop, obj, value)
proc `set bIgnoreRadialForce`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bIgnoreRadialForce")
setValueInBoolProp(prop, obj, value)
proc `bApplyImpulseOnDamage`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bApplyImpulseOnDamage")
getValueFromBoolProp(prop, obj)
proc `bApplyImpulseOnDamage=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bApplyImpulseOnDamage")
setValueInBoolProp(prop, obj, value)
proc `set bApplyImpulseOnDamage`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bApplyImpulseOnDamage")
setValueInBoolProp(prop, obj, value)
proc `bReplicatePhysicsToAutonomousProxy`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bReplicatePhysicsToAutonomousProxy")
getValueFromBoolProp(prop, obj)
proc `bReplicatePhysicsToAutonomousProxy=`*(
obj : UPrimitiveComponentPtr; val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bReplicatePhysicsToAutonomousProxy")
setValueInBoolProp(prop, obj, value)
proc `set bReplicatePhysicsToAutonomousProxy`*(
obj : UPrimitiveComponentPtr; val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bReplicatePhysicsToAutonomousProxy")
setValueInBoolProp(prop, obj, value)
proc `bRenderCustomDepth`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bRenderCustomDepth")
getValueFromBoolProp(prop, obj)
proc `bRenderCustomDepth=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bRenderCustomDepth")
setValueInBoolProp(prop, obj, value)
proc `set bRenderCustomDepth`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bRenderCustomDepth")
setValueInBoolProp(prop, obj, value)
proc `bVisibleInSceneCaptureOnly`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bVisibleInSceneCaptureOnly")
getValueFromBoolProp(prop, obj)
proc `bVisibleInSceneCaptureOnly=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bVisibleInSceneCaptureOnly")
setValueInBoolProp(prop, obj, value)
proc `set bVisibleInSceneCaptureOnly`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bVisibleInSceneCaptureOnly")
setValueInBoolProp(prop, obj, value)
proc `bHiddenInSceneCapture`*(obj : UPrimitiveComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bHiddenInSceneCapture")
getValueFromBoolProp(prop, obj)
proc `bHiddenInSceneCapture=`*(obj : UPrimitiveComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bHiddenInSceneCapture")
setValueInBoolProp(prop, obj, value)
proc `set bHiddenInSceneCapture`*(obj : UPrimitiveComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"bHiddenInSceneCapture")
setValueInBoolProp(prop, obj, value)
proc `canCharacterStepUpOn`*(obj : UPrimitiveComponentPtr): ECanBeCharacterBase {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"CanCharacterStepUpOn")
getPropertyValuePtr[ECanBeCharacterBase](prop, obj)[]
proc `canCharacterStepUpOn=`*(obj : UPrimitiveComponentPtr;
val : ECanBeCharacterBase) =
var value : ECanBeCharacterBase = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"CanCharacterStepUpOn")
setPropertyValuePtr[ECanBeCharacterBase](prop, obj, value.addr)
proc `set canCharacterStepUpOn`*(obj : UPrimitiveComponentPtr;
val : ECanBeCharacterBase) {.
exportcpp.} =
var value : ECanBeCharacterBase = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"CanCharacterStepUpOn")
setPropertyValuePtr[ECanBeCharacterBase](prop, obj, value.addr)
proc `lightingChannels`*(obj : UPrimitiveComponentPtr): var FLightingChannels {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"LightingChannels")
getPropertyValuePtr[FLightingChannels](prop, obj)[]
proc `lightingChannels=`*(obj : UPrimitiveComponentPtr;
val : FLightingChannels) =
var value : FLightingChannels = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"LightingChannels")
setPropertyValuePtr[FLightingChannels](prop, obj, value.addr)
proc `set lightingChannels`*(obj : UPrimitiveComponentPtr;
val : FLightingChannels) {.exportcpp.} =
var value : FLightingChannels = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"LightingChannels")
setPropertyValuePtr[FLightingChannels](prop, obj, value.addr)
proc `rayTracingGroupId`*(obj : UPrimitiveComponentPtr): int32 {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"RayTracingGroupId")
getPropertyValuePtr[int32](prop, obj)[]
proc `rayTracingGroupId=`*(obj : UPrimitiveComponentPtr;
val : int32) =
var value : int32 = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"RayTracingGroupId")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `set rayTracingGroupId`*(obj : UPrimitiveComponentPtr;
val : int32) {.exportcpp.} =
var value : int32 = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"RayTracingGroupId")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `customDepthStencilValue`*(obj : UPrimitiveComponentPtr): int32 {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"CustomDepthStencilValue")
getPropertyValuePtr[int32](prop, obj)[]
proc `customDepthStencilValue=`*(obj : UPrimitiveComponentPtr;
val : int32) =
var value : int32 = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"CustomDepthStencilValue")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `set customDepthStencilValue`*(obj : UPrimitiveComponentPtr;
val : int32) {.exportcpp.} =
var value : int32 = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"CustomDepthStencilValue")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `translucencySortPriority`*(obj : UPrimitiveComponentPtr): int32 {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"TranslucencySortPriority")
getPropertyValuePtr[int32](prop, obj)[]
proc `translucencySortPriority=`*(obj : UPrimitiveComponentPtr;
val : int32) =
var value : int32 = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"TranslucencySortPriority")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `set translucencySortPriority`*(obj : UPrimitiveComponentPtr;
val : int32) {.exportcpp.} =
var value : int32 = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"TranslucencySortPriority")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `translucencySortDistanceOffset`*(obj : UPrimitiveComponentPtr): float32 {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"TranslucencySortDistanceOffset")
getPropertyValuePtr[float32](prop, obj)[]
proc `translucencySortDistanceOffset=`*(obj : UPrimitiveComponentPtr;
val : float32) =
var value : float32 = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"TranslucencySortDistanceOffset")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set translucencySortDistanceOffset`*(
obj : UPrimitiveComponentPtr; val : float32) {.exportcpp.} =
var value : float32 = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"TranslucencySortDistanceOffset")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `runtimeVirtualTextures`*(obj : UPrimitiveComponentPtr): var TArray[
URuntimeVirtualTexturePtr] {.exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"RuntimeVirtualTextures")
getPropertyValuePtr[TArray[URuntimeVirtualTexturePtr]](prop, obj)[]
proc `runtimeVirtualTextures=`*(obj : UPrimitiveComponentPtr;
val : TArray[URuntimeVirtualTexturePtr]) =
var value : TArray[URuntimeVirtualTexturePtr] = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"RuntimeVirtualTextures")
setPropertyValuePtr[TArray[URuntimeVirtualTexturePtr]](prop, obj, value.addr)
proc `set runtimeVirtualTextures`*(obj : UPrimitiveComponentPtr;
val : TArray[URuntimeVirtualTexturePtr]) {.exportcpp.} =
var value : TArray[URuntimeVirtualTexturePtr] = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"RuntimeVirtualTextures")
setPropertyValuePtr[TArray[URuntimeVirtualTexturePtr]](prop, obj, value.addr)
proc `virtualTextureRenderPassType`*(obj : UPrimitiveComponentPtr): ERuntimeVirtualTextureMainPassType {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"VirtualTextureRenderPassType")
getPropertyValuePtr[ERuntimeVirtualTextureMainPassType](prop, obj)[]
proc `virtualTextureRenderPassType=`*(obj : UPrimitiveComponentPtr;
val : ERuntimeVirtualTextureMainPassType) =
var value : ERuntimeVirtualTextureMainPassType = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"VirtualTextureRenderPassType")
setPropertyValuePtr[ERuntimeVirtualTextureMainPassType](prop, obj, value.addr)
proc `set virtualTextureRenderPassType`*(obj : UPrimitiveComponentPtr;
val : ERuntimeVirtualTextureMainPassType) {.exportcpp.} =
var value : ERuntimeVirtualTextureMainPassType = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"VirtualTextureRenderPassType")
setPropertyValuePtr[ERuntimeVirtualTextureMainPassType](prop, obj, value.addr)
proc `bodyInstance`*(obj : UPrimitiveComponentPtr): var FBodyInstance {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"BodyInstance")
getPropertyValuePtr[FBodyInstance](prop, obj)[]
proc `bodyInstance=`*(obj : UPrimitiveComponentPtr;
val : FBodyInstance) =
var value : FBodyInstance = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"BodyInstance")
setPropertyValuePtr[FBodyInstance](prop, obj, value.addr)
proc `set bodyInstance`*(obj : UPrimitiveComponentPtr;
val : FBodyInstance) {.exportcpp.} =
var value : FBodyInstance = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"BodyInstance")
setPropertyValuePtr[FBodyInstance](prop, obj, value.addr)
proc `rayTracingGroupCullingPriority`*(obj : UPrimitiveComponentPtr): ERayTracingGroupCullingPriority {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"RayTracingGroupCullingPriority")
getPropertyValuePtr[ERayTracingGroupCullingPriority](prop, obj)[]
proc `rayTracingGroupCullingPriority=`*(obj : UPrimitiveComponentPtr;
val : ERayTracingGroupCullingPriority) =
var value : ERayTracingGroupCullingPriority = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"RayTracingGroupCullingPriority")
setPropertyValuePtr[ERayTracingGroupCullingPriority](prop, obj, value.addr)
proc `set rayTracingGroupCullingPriority`*(
obj : UPrimitiveComponentPtr;
val : ERayTracingGroupCullingPriority) {.exportcpp.} =
var value : ERayTracingGroupCullingPriority = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"RayTracingGroupCullingPriority")
setPropertyValuePtr[ERayTracingGroupCullingPriority](prop, obj, value.addr)
proc `customDepthStencilWriteMask`*(obj : UPrimitiveComponentPtr): ERendererStencilMask {.
exportcpp.} =
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"CustomDepthStencilWriteMask")
getPropertyValuePtr[ERendererStencilMask](prop, obj)[]
proc `customDepthStencilWriteMask=`*(obj : UPrimitiveComponentPtr;
val : ERendererStencilMask) =
var value : ERendererStencilMask = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"CustomDepthStencilWriteMask")
setPropertyValuePtr[ERendererStencilMask](prop, obj, value.addr)
proc `set customDepthStencilWriteMask`*(obj : UPrimitiveComponentPtr;
val : ERendererStencilMask) {.
exportcpp.} =
var value : ERendererStencilMask = val
let prop = getClassByName("PrimitiveComponent").getFPropertyByName(
"CustomDepthStencilWriteMask")
setPropertyValuePtr[ERendererStencilMask](prop, obj, value.addr)
proc wasRecentlyRendered*(self : UPrimitiveComponentPtr;
tolerance : float32 = 0.2'f32): bool {.
exportcpp: "$1_".} =
type
Params = object
tolerance: float32
returnValue: bool
var param = Params(tolerance: tolerance)
let fnName {.used.} = n "WasRecentlyRendered"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc wakeRigidBody*(self : UPrimitiveComponentPtr;
boneName : FName = makeFName("None")): void {.
exportcpp: "$1_".} =
type
Params = object
boneName: FName
var param = Params(boneName: boneName)
let fnName {.used.} = n "WakeRigidBody"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc wakeAllRigidBodies*(self : UPrimitiveComponentPtr): void {.
exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "WakeAllRigidBodies"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setWalkableSlopeOverride*(self : UPrimitiveComponentPtr;
newOverride : var FWalkableSlopeOverride): void {.exportcpp: "$1_".} =
type
Params = object
newOverride: FWalkableSlopeOverride
var param = Params(newOverride: newOverride)
let fnName {.used.} = n "SetWalkableSlopeOverride"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
newOverride = param.newOverride
proc setVisibleInSceneCaptureOnly*(self : UPrimitiveComponentPtr;
bValue : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bValue: bool
var param = Params(bValue: bValue)
let fnName {.used.} = n "SetVisibleInSceneCaptureOnly"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setVisibleInRayTracing*(self : UPrimitiveComponentPtr;
bNewVisibleInRayTracing : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bNewVisibleInRayTracing: bool
var param = Params(bNewVisibleInRayTracing: bNewVisibleInRayTracing)
let fnName {.used.} = n "SetVisibleInRayTracing"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setVectorParameterForDefaultCustomPrimitiveData*(
self : UPrimitiveComponentPtr; parameterName : FName;
value : FVector4): void {.exportcpp: "$1_".} =
type
Params = object
parameterName: FName
value: FVector4
var param = Params(parameterName: parameterName, value: value)
let fnName {.used.} = n "SetVectorParameterForDefaultCustomPrimitiveData"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setVectorParameterForCustomPrimitiveData*(
self : UPrimitiveComponentPtr; parameterName : FName;
value : FVector4): void {.exportcpp: "$1_".} =
type
Params = object
parameterName: FName
value: FVector4
var param = Params(parameterName: parameterName, value: value)
let fnName {.used.} = n "SetVectorParameterForCustomPrimitiveData"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setUseCCD*(self : UPrimitiveComponentPtr;
inUseCCD : bool;
boneName : FName = makeFName("None")): void {.
exportcpp: "$1_".} =
type
Params = object
inUseCCD: bool
boneName: FName
var param = Params(inUseCCD: inUseCCD, boneName: boneName)
let fnName {.used.} = n "SetUseCCD"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setTranslucentSortPriority*(self : UPrimitiveComponentPtr;
newTranslucentSortPriority : int32): void {.
exportcpp: "$1_".} =
type
Params = object
newTranslucentSortPriority: int32
var param = Params(newTranslucentSortPriority: newTranslucentSortPriority)
let fnName {.used.} = n "SetTranslucentSortPriority"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setTranslucencySortDistanceOffset*(self : UPrimitiveComponentPtr;
newTranslucencySortDistanceOffset : float32): void {.
exportcpp: "$1_".} =
type
Params = object
newTranslucencySortDistanceOffset: float32
var param = Params(newTranslucencySortDistanceOffset: newTranslucencySortDistanceOffset)
let fnName {.used.} = n "SetTranslucencySortDistanceOffset"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setSingleSampleShadowFromStationaryLights*(
self : UPrimitiveComponentPtr;
bNewSingleSampleShadowFromStationaryLights : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bNewSingleSampleShadowFromStationaryLights: bool
var param = Params(bNewSingleSampleShadowFromStationaryLights: bNewSingleSampleShadowFromStationaryLights)
let fnName {.used.} = n "SetSingleSampleShadowFromStationaryLights"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setSimulatePhysics*(self : UPrimitiveComponentPtr;
bSimulate : bool): void {.exportcpp: "$1_".} =
type
Params = object
bSimulate: bool
var param = Params(bSimulate: bSimulate)
let fnName {.used.} = n "SetSimulatePhysics"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setScalarParameterForDefaultCustomPrimitiveData*(
self : UPrimitiveComponentPtr; parameterName : FName;
value : float32): void {.exportcpp: "$1_".} =
type
Params = object
parameterName: FName
value: float32
var param = Params(parameterName: parameterName, value: value)
let fnName {.used.} = n "SetScalarParameterForDefaultCustomPrimitiveData"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setScalarParameterForCustomPrimitiveData*(
self : UPrimitiveComponentPtr; parameterName : FName;
value : float32): void {.exportcpp: "$1_".} =
type
Params = object
parameterName: FName
value: float32
var param = Params(parameterName: parameterName, value: value)
let fnName {.used.} = n "SetScalarParameterForCustomPrimitiveData"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setRenderInMainPass*(self : UPrimitiveComponentPtr;
bValue : bool): void {.exportcpp: "$1_".} =
type
Params = object
bValue: bool
var param = Params(bValue: bValue)
let fnName {.used.} = n "SetRenderInMainPass"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setRenderInDepthPass*(self : UPrimitiveComponentPtr;
bValue : bool): void {.exportcpp: "$1_".} =
type
Params = object
bValue: bool
var param = Params(bValue: bValue)
let fnName {.used.} = n "SetRenderInDepthPass"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setRenderCustomDepth*(self : UPrimitiveComponentPtr;
bValue : bool): void {.exportcpp: "$1_".} =
type
Params = object
bValue: bool
var param = Params(bValue: bValue)
let fnName {.used.} = n "SetRenderCustomDepth"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setReceivesDecals*(self : UPrimitiveComponentPtr;
bNewReceivesDecals : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bNewReceivesDecals: bool
var param = Params(bNewReceivesDecals: bNewReceivesDecals)
let fnName {.used.} = n "SetReceivesDecals"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setPhysMaterialOverride*(self : UPrimitiveComponentPtr;
newPhysMaterial : UPhysicalMaterialPtr): void {.
exportcpp: "$1_".} =
type
Params = object
newPhysMaterial: UPhysicalMaterialPtr
var param = Params(newPhysMaterial: newPhysMaterial)
let fnName {.used.} = n "SetPhysMaterialOverride"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setPhysicsMaxAngularVelocityInRadians*(
self : UPrimitiveComponentPtr; newMaxAngVel : float32;
bAddToCurrent : bool = false;
boneName : FName = makeFName("None")): void {.exportcpp: "$1_".} =
type
Params = object
newMaxAngVel: float32
bAddToCurrent: bool
boneName: FName
var param = Params(newMaxAngVel: newMaxAngVel,
bAddToCurrent: bAddToCurrent, boneName: boneName)
let fnName {.used.} = n "SetPhysicsMaxAngularVelocityInRadians"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setPhysicsMaxAngularVelocityInDegrees*(
self : UPrimitiveComponentPtr; newMaxAngVel : float32;
bAddToCurrent : bool = false;
boneName : FName = makeFName("None")): void {.exportcpp: "$1_".} =
type
Params = object
newMaxAngVel: float32
bAddToCurrent: bool
boneName: FName
var param = Params(newMaxAngVel: newMaxAngVel,
bAddToCurrent: bAddToCurrent, boneName: boneName)
let fnName {.used.} = n "SetPhysicsMaxAngularVelocityInDegrees"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setPhysicsLinearVelocity*(self : UPrimitiveComponentPtr;
newVel : FVector;
bAddToCurrent : bool = false;
boneName : FName = makeFName("None")): void {.
exportcpp: "$1_".} =
type
Params = object
newVel: FVector
bAddToCurrent: bool
boneName: FName
var param = Params(newVel: newVel, bAddToCurrent: bAddToCurrent,
boneName: boneName)
let fnName {.used.} = n "SetPhysicsLinearVelocity"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setPhysicsAngularVelocityInRadians*(self : UPrimitiveComponentPtr;
newAngVel : FVector; bAddToCurrent : bool = false;
boneName : FName = makeFName("None")): void {.exportcpp: "$1_".} =
type
Params = object
newAngVel: FVector
bAddToCurrent: bool
boneName: FName
var param = Params(newAngVel: newAngVel,
bAddToCurrent: bAddToCurrent, boneName: boneName)
let fnName {.used.} = n "SetPhysicsAngularVelocityInRadians"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setPhysicsAngularVelocityInDegrees*(self : UPrimitiveComponentPtr;
newAngVel : FVector; bAddToCurrent : bool = false;
boneName : FName = makeFName("None")): void {.exportcpp: "$1_".} =
type
Params = object
newAngVel: FVector
bAddToCurrent: bool
boneName: FName
var param = Params(newAngVel: newAngVel,
bAddToCurrent: bAddToCurrent, boneName: boneName)
let fnName {.used.} = n "SetPhysicsAngularVelocityInDegrees"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setOwnerNoSee*(self : UPrimitiveComponentPtr;
bNewOwnerNoSee : bool): void {.exportcpp: "$1_".} =
type
Params = object
bNewOwnerNoSee: bool
var param = Params(bNewOwnerNoSee: bNewOwnerNoSee)
let fnName {.used.} = n "SetOwnerNoSee"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setOnlyOwnerSee*(self : UPrimitiveComponentPtr;
bNewOnlyOwnerSee : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bNewOnlyOwnerSee: bool
var param = Params(bNewOnlyOwnerSee: bNewOnlyOwnerSee)
let fnName {.used.} = n "SetOnlyOwnerSee"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setNotifyRigidBodyCollision*(self : UPrimitiveComponentPtr;
bNewNotifyRigidBodyCollision : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bNewNotifyRigidBodyCollision: bool
var param = Params(bNewNotifyRigidBodyCollision: bNewNotifyRigidBodyCollision)
let fnName {.used.} = n "SetNotifyRigidBodyCollision"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setMaterialByName*(self : UPrimitiveComponentPtr;
materialSlotName : FName;
material : UMaterialInterfacePtr): void {.
exportcpp: "$1_".} =
type
Params = object
materialSlotName: FName
material: UMaterialInterfacePtr
var param = Params(materialSlotName: materialSlotName,
material: material)
let fnName {.used.} = n "SetMaterialByName"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setMaterial*(self : UPrimitiveComponentPtr;
elementIndex : int32;
material : UMaterialInterfacePtr): void {.
exportcpp: "$1_".} =
type
Params = object
elementIndex: int32
material: UMaterialInterfacePtr
var param = Params(elementIndex: elementIndex, material: material)
let fnName {.used.} = n "SetMaterial"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setMassScale*(self : UPrimitiveComponentPtr;
boneName : FName = makeFName("None");
inMassScale : float32 = 1.0'f32): void {.
exportcpp: "$1_".} =
type
Params = object
boneName: FName
inMassScale: float32
var param = Params(boneName: boneName, inMassScale: inMassScale)
let fnName {.used.} = n "SetMassScale"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setMassOverrideInKg*(self : UPrimitiveComponentPtr;
boneName : FName = makeFName("None");
massInKg : float32 = 1.0'f32;
bOverrideMass : bool = true): void {.
exportcpp: "$1_".} =
type
Params = object
boneName: FName
massInKg: float32
bOverrideMass: bool
var param = Params(boneName: boneName, massInKg: massInKg,
bOverrideMass: bOverrideMass)
let fnName {.used.} = n "SetMassOverrideInKg"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setLinearDamping*(self : UPrimitiveComponentPtr;
inDamping : float32): void {.exportcpp: "$1_".} =
type
Params = object
inDamping: float32
var param = Params(inDamping: inDamping)
let fnName {.used.} = n "SetLinearDamping"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setLightingChannels*(self : UPrimitiveComponentPtr;
bChannel0 : bool; bChannel1 : bool;
bChannel2 : bool): void {.exportcpp: "$1_".} =
type
Params = object
bChannel0: bool
bChannel1: bool
bChannel2: bool
var param = Params(bChannel0: bChannel0, bChannel1: bChannel1,
bChannel2: bChannel2)
let fnName {.used.} = n "SetLightingChannels"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setLightAttachmentsAsGroup*(self : UPrimitiveComponentPtr;
bInLightAttachmentsAsGroup : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bInLightAttachmentsAsGroup: bool
var param = Params(bInLightAttachmentsAsGroup: bInLightAttachmentsAsGroup)
let fnName {.used.} = n "SetLightAttachmentsAsGroup"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setHiddenInSceneCapture*(self : UPrimitiveComponentPtr;
bValue : bool): void {.exportcpp: "$1_".} =
type
Params = object
bValue: bool
var param = Params(bValue: bValue)
let fnName {.used.} = n "SetHiddenInSceneCapture"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setGenerateOverlapEvents*(self : UPrimitiveComponentPtr;
bInGenerateOverlapEvents : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bInGenerateOverlapEvents: bool
var param = Params(bInGenerateOverlapEvents: bInGenerateOverlapEvents)
let fnName {.used.} = n "SetGenerateOverlapEvents"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setExcludeFromLightAttachmentGroup*(self : UPrimitiveComponentPtr;
bInExcludeFromLightAttachmentGroup : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bInExcludeFromLightAttachmentGroup: bool
var param = Params(bInExcludeFromLightAttachmentGroup: bInExcludeFromLightAttachmentGroup)
let fnName {.used.} = n "SetExcludeFromLightAttachmentGroup"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setEnableGravity*(self : UPrimitiveComponentPtr;
bGravityEnabled : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bGravityEnabled: bool
var param = Params(bGravityEnabled: bGravityEnabled)
let fnName {.used.} = n "SetEnableGravity"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setEmissiveLightSource*(self : UPrimitiveComponentPtr;
newEmissiveLightSource : bool): void {.
exportcpp: "$1_".} =
type
Params = object
newEmissiveLightSource: bool
var param = Params(newEmissiveLightSource: newEmissiveLightSource)
let fnName {.used.} = n "SetEmissiveLightSource"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setDefaultCustomPrimitiveDataVector4*(
self : UPrimitiveComponentPtr; dataIndex : int32;
value : FVector4): void {.exportcpp: "$1_".} =
type
Params = object
dataIndex: int32
value: FVector4
var param = Params(dataIndex: dataIndex, value: value)
let fnName {.used.} = n "SetDefaultCustomPrimitiveDataVector4"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setDefaultCustomPrimitiveDataVector3*(
self : UPrimitiveComponentPtr; dataIndex : int32;
value : FVector): void {.exportcpp: "$1_".} =
type
Params = object
dataIndex: int32
value: FVector
var param = Params(dataIndex: dataIndex, value: value)
let fnName {.used.} = n "SetDefaultCustomPrimitiveDataVector3"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setDefaultCustomPrimitiveDataVector2*(
self : UPrimitiveComponentPtr; dataIndex : int32;
value : FVector2D): void {.exportcpp: "$1_".} =
type
Params = object
dataIndex: int32
value: FVector2D
var param = Params(dataIndex: dataIndex, value: value)
let fnName {.used.} = n "SetDefaultCustomPrimitiveDataVector2"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setDefaultCustomPrimitiveDataFloat*(self : UPrimitiveComponentPtr;
dataIndex : int32; value : float32): void {.
exportcpp: "$1_".} =
type
Params = object
dataIndex: int32
value: float32
var param = Params(dataIndex: dataIndex, value: value)
let fnName {.used.} = n "SetDefaultCustomPrimitiveDataFloat"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setCustomPrimitiveDataVector4*(self : UPrimitiveComponentPtr;
dataIndex : int32;
value : FVector4): void {.
exportcpp: "$1_".} =
type
Params = object
dataIndex: int32
value: FVector4
var param = Params(dataIndex: dataIndex, value: value)
let fnName {.used.} = n "SetCustomPrimitiveDataVector4"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setCustomPrimitiveDataVector3*(self : UPrimitiveComponentPtr;
dataIndex : int32;
value : FVector): void {.
exportcpp: "$1_".} =
type
Params = object
dataIndex: int32
value: FVector
var param = Params(dataIndex: dataIndex, value: value)
let fnName {.used.} = n "SetCustomPrimitiveDataVector3"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setCustomPrimitiveDataVector2*(self : UPrimitiveComponentPtr;
dataIndex : int32;
value : FVector2D): void {.
exportcpp: "$1_".} =
type
Params = object
dataIndex: int32
value: FVector2D
var param = Params(dataIndex: dataIndex, value: value)
let fnName {.used.} = n "SetCustomPrimitiveDataVector2"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setCustomPrimitiveDataFloat*(self : UPrimitiveComponentPtr;
dataIndex : int32;
value : float32): void {.
exportcpp: "$1_".} =
type
Params = object
dataIndex: int32
value: float32
var param = Params(dataIndex: dataIndex, value: value)
let fnName {.used.} = n "SetCustomPrimitiveDataFloat"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setCustomDepthStencilWriteMask*(self : UPrimitiveComponentPtr;
writeMaskBit : ERendererStencilMask): void {.exportcpp: "$1_".} =
type
Params = object
writeMaskBit: ERendererStencilMask
var param = Params(writeMaskBit: writeMaskBit)
let fnName {.used.} = n "SetCustomDepthStencilWriteMask"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setCustomDepthStencilValue*(self : UPrimitiveComponentPtr;
value : int32): void {.
exportcpp: "$1_".} =
type
Params = object
value: int32
var param = Params(value: value)
let fnName {.used.} = n "SetCustomDepthStencilValue"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setCullDistance*(self : UPrimitiveComponentPtr;
newCullDistance : float32): void {.
exportcpp: "$1_".} =
type
Params = object
newCullDistance: float32
var param = Params(newCullDistance: newCullDistance)
let fnName {.used.} = n "SetCullDistance"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setConstraintMode*(self : UPrimitiveComponentPtr;
constraintMode : EDOFMode): void {.
exportcpp: "$1_".} =
type
Params = object
constraintMode: EDOFMode
var param = Params(constraintMode: constraintMode)
let fnName {.used.} = n "SetConstraintMode"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setCollisionResponseToChannel*(self : UPrimitiveComponentPtr;
channel : ECollisionChannel;
newResponse : ECollisionResponse): void {.
exportcpp: "$1_".} =
type
Params = object
channel: ECollisionChannel
newResponse: ECollisionResponse
var param = Params(channel: channel, newResponse: newResponse)
let fnName {.used.} = n "SetCollisionResponseToChannel"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setCollisionResponseToAllChannels*(self : UPrimitiveComponentPtr;
newResponse : ECollisionResponse): void {.exportcpp: "$1_".} =
type
Params = object
newResponse: ECollisionResponse
var param = Params(newResponse: newResponse)
let fnName {.used.} = n "SetCollisionResponseToAllChannels"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setCollisionProfileName*(self : UPrimitiveComponentPtr;
inCollisionProfileName : FName;
bUpdateOverlaps : bool = true): void {.
exportcpp: "$1_".} =
type
Params = object
inCollisionProfileName: FName
bUpdateOverlaps: bool
var param = Params(inCollisionProfileName: inCollisionProfileName,
bUpdateOverlaps: bUpdateOverlaps)
let fnName {.used.} = n "SetCollisionProfileName"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setCollisionObjectType*(self : UPrimitiveComponentPtr;
channel : ECollisionChannel): void {.
exportcpp: "$1_".} =
type
Params = object
channel: ECollisionChannel
var param = Params(channel: channel)
let fnName {.used.} = n "SetCollisionObjectType"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setCollisionEnabled*(self : UPrimitiveComponentPtr;
newType : ECollisionEnabled): void {.
exportcpp: "$1_".} =
type
Params = object
newType: ECollisionEnabled
var param = Params(newType: newType)
let fnName {.used.} = n "SetCollisionEnabled"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setCenterOfMass*(self : UPrimitiveComponentPtr;
centerOfMassOffset : FVector;
boneName : FName = makeFName("None")): void {.
exportcpp: "$1_".} =
type
Params = object
centerOfMassOffset: FVector
boneName: FName
var param = Params(centerOfMassOffset: centerOfMassOffset,
boneName: boneName)
let fnName {.used.} = n "SetCenterOfMass"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setCastShadow*(self : UPrimitiveComponentPtr;
newCastShadow : bool): void {.exportcpp: "$1_".} =
type
Params = object
newCastShadow: bool
var param = Params(newCastShadow: newCastShadow)
let fnName {.used.} = n "SetCastShadow"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setCastInsetShadow*(self : UPrimitiveComponentPtr;
bInCastInsetShadow : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bInCastInsetShadow: bool
var param = Params(bInCastInsetShadow: bInCastInsetShadow)
let fnName {.used.} = n "SetCastInsetShadow"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setCastHiddenShadow*(self : UPrimitiveComponentPtr;
newCastHiddenShadow : bool): void {.
exportcpp: "$1_".} =
type
Params = object
newCastHiddenShadow: bool
var param = Params(newCastHiddenShadow: newCastHiddenShadow)
let fnName {.used.} = n "SetCastHiddenShadow"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setCastContactShadow*(self : UPrimitiveComponentPtr;
bInCastContactShadow : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bInCastContactShadow: bool
var param = Params(bInCastContactShadow: bInCastContactShadow)
let fnName {.used.} = n "SetCastContactShadow"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setBoundsScale*(self : UPrimitiveComponentPtr;
newBoundsScale : float32 = 1.0'f32): void {.
exportcpp: "$1_".} =
type
Params = object
newBoundsScale: float32
var param = Params(newBoundsScale: newBoundsScale)
let fnName {.used.} = n "SetBoundsScale"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setAngularDamping*(self : UPrimitiveComponentPtr;
inDamping : float32): void {.exportcpp: "$1_".} =
type
Params = object
inDamping: float32
var param = Params(inDamping: inDamping)
let fnName {.used.} = n "SetAngularDamping"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setAllUseCCD*(self : UPrimitiveComponentPtr;
inUseCCD : bool): void {.exportcpp: "$1_".} =
type
Params = object
inUseCCD: bool
var param = Params(inUseCCD: inUseCCD)
let fnName {.used.} = n "SetAllUseCCD"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setAllPhysicsLinearVelocity*(self : UPrimitiveComponentPtr;
newVel : FVector;
bAddToCurrent : bool = false): void {.
exportcpp: "$1_".} =
type
Params = object
newVel: FVector
bAddToCurrent: bool
var param = Params(newVel: newVel, bAddToCurrent: bAddToCurrent)
let fnName {.used.} = n "SetAllPhysicsLinearVelocity"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setAllPhysicsAngularVelocityInRadians*(
self : UPrimitiveComponentPtr; newAngVel : var FVector;
bAddToCurrent : bool = false): void {.exportcpp: "$1_".} =
type
Params = object
newAngVel: FVector
bAddToCurrent: bool
var param = Params(newAngVel: newAngVel,
bAddToCurrent: bAddToCurrent)
let fnName {.used.} = n "SetAllPhysicsAngularVelocityInRadians"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
newAngVel = param.newAngVel
proc setAllPhysicsAngularVelocityInDegrees*(
self : UPrimitiveComponentPtr; newAngVel : var FVector;
bAddToCurrent : bool = false): void {.exportcpp: "$1_".} =
type
Params = object
newAngVel: FVector
bAddToCurrent: bool
var param = Params(newAngVel: newAngVel,
bAddToCurrent: bAddToCurrent)
let fnName {.used.} = n "SetAllPhysicsAngularVelocityInDegrees"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
newAngVel = param.newAngVel
proc setAllMassScale*(self : UPrimitiveComponentPtr;
inMassScale : float32 = 1.0'f32): void {.
exportcpp: "$1_".} =
type
Params = object
inMassScale: float32
var param = Params(inMassScale: inMassScale)
let fnName {.used.} = n "SetAllMassScale"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc scaleByMomentOfInertia*(self : UPrimitiveComponentPtr;
inputVector : FVector;
boneName : FName = makeFName("None")): FVector {.
exportcpp: "$1_".} =
type
Params = object
inputVector: FVector
boneName: FName
returnValue: FVector
var param = Params(inputVector: inputVector, boneName: boneName)
let fnName {.used.} = n "ScaleByMomentOfInertia"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc putRigidBodyToSleep*(self : UPrimitiveComponentPtr;
boneName : FName = makeFName("None")): void {.
exportcpp: "$1_".} =
type
Params = object
boneName: FName
var param = Params(boneName: boneName)
let fnName {.used.} = n "PutRigidBodyToSleep"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc sphereTraceComponent*(self : UPrimitiveComponentPtr;
traceStart : FVector;
traceEnd : FVector;
sphereRadius : float32;
bTraceComplex : bool;
bShowTrace : bool;
bPersistentShowTrace : bool;
hitLocation : var FVector;
hitNormal : var FVector;
boneName : var FName;
outHit : var FHitResult): bool {.
exportcpp: "$1_".} =
type
Params = object
traceStart: FVector
traceEnd: FVector
sphereRadius: float32
bTraceComplex: bool
bShowTrace: bool
bPersistentShowTrace: bool
hitLocation: FVector
hitNormal: FVector
boneName: FName
outHit: FHitResult
returnValue: bool
var param = Params(traceStart: traceStart, traceEnd: traceEnd,
sphereRadius: sphereRadius,
bTraceComplex: bTraceComplex,
bShowTrace: bShowTrace,
bPersistentShowTrace: bPersistentShowTrace,
hitLocation: hitLocation, hitNormal: hitNormal,
boneName: boneName, outHit: outHit)
let fnName {.used.} = n "K2_SphereTraceComponent"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
hitLocation = param.hitLocation
hitNormal = param.hitNormal
boneName = param.boneName
outHit = param.outHit
return param.returnValue
proc sphereOverlapComponent*(self : UPrimitiveComponentPtr;
inSphereCentre : FVector;
inSphereRadius : float32;
bTraceComplex : bool;
bShowTrace : bool;
bPersistentShowTrace : bool;
hitLocation : var FVector;
hitNormal : var FVector;
boneName : var FName;
outHit : var FHitResult): bool {.
exportcpp: "$1_".} =
type
Params = object
inSphereCentre: FVector
inSphereRadius: float32
bTraceComplex: bool
bShowTrace: bool
bPersistentShowTrace: bool
hitLocation: FVector
hitNormal: FVector
boneName: FName
outHit: FHitResult
returnValue: bool
var param = Params(inSphereCentre: inSphereCentre,
inSphereRadius: inSphereRadius,
bTraceComplex: bTraceComplex,
bShowTrace: bShowTrace,
bPersistentShowTrace: bPersistentShowTrace,
hitLocation: hitLocation, hitNormal: hitNormal,
boneName: boneName, outHit: outHit)
let fnName {.used.} = n "K2_SphereOverlapComponent"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
hitLocation = param.hitLocation
hitNormal = param.hitNormal
boneName = param.boneName
outHit = param.outHit
return param.returnValue
proc lineTraceComponent*(self : UPrimitiveComponentPtr;
traceStart : FVector;
traceEnd : FVector;
bTraceComplex : bool;
bShowTrace : bool;
bPersistentShowTrace : bool;
hitLocation : var FVector;
hitNormal : var FVector;
boneName : var FName;
outHit : var FHitResult): bool {.
exportcpp: "$1_".} =
type
Params = object
traceStart: FVector
traceEnd: FVector
bTraceComplex: bool
bShowTrace: bool
bPersistentShowTrace: bool
hitLocation: FVector
hitNormal: FVector
boneName: FName
outHit: FHitResult
returnValue: bool
var param = Params(traceStart: traceStart, traceEnd: traceEnd,
bTraceComplex: bTraceComplex,
bShowTrace: bShowTrace,
bPersistentShowTrace: bPersistentShowTrace,
hitLocation: hitLocation, hitNormal: hitNormal,
boneName: boneName, outHit: outHit)
let fnName {.used.} = n "K2_LineTraceComponent"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
hitLocation = param.hitLocation
hitNormal = param.hitNormal
boneName = param.boneName
outHit = param.outHit
return param.returnValue
proc isQueryCollisionEnabled*(self : UPrimitiveComponentPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "K2_IsQueryCollisionEnabled"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isPhysicsCollisionEnabled*(self : UPrimitiveComponentPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "K2_IsPhysicsCollisionEnabled"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isCollisionEnabled*(self : UPrimitiveComponentPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "K2_IsCollisionEnabled"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc boxOverlapComponent*(self : UPrimitiveComponentPtr;
inBoxCentre : FVector;
inBox : FBox; bTraceComplex : bool;
bShowTrace : bool;
bPersistentShowTrace : bool;
hitLocation : var FVector;
hitNormal : var FVector;
boneName : var FName;
outHit : var FHitResult): bool {.
exportcpp: "$1_".} =
type
Params = object
inBoxCentre: FVector
inBox: FBox
bTraceComplex: bool
bShowTrace: bool
bPersistentShowTrace: bool
hitLocation: FVector
hitNormal: FVector
boneName: FName
outHit: FHitResult
returnValue: bool
var param = Params(inBoxCentre: inBoxCentre, inBox: inBox,
bTraceComplex: bTraceComplex,
bShowTrace: bShowTrace,
bPersistentShowTrace: bPersistentShowTrace,
hitLocation: hitLocation, hitNormal: hitNormal,
boneName: boneName, outHit: outHit)
let fnName {.used.} = n "K2_BoxOverlapComponent"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
hitLocation = param.hitLocation
hitNormal = param.hitNormal
boneName = param.boneName
outHit = param.outHit
return param.returnValue
proc isOverlappingComponent*(self : UPrimitiveComponentPtr;
otherComp : UPrimitiveComponentPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
otherComp: UPrimitiveComponentPtr
returnValue: bool
var param = Params(otherComp: otherComp)
let fnName {.used.} = n "IsOverlappingComponent"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isOverlappingActor*(self : UPrimitiveComponentPtr;
other : AActorPtr): bool {.exportcpp: "$1_".} =
type
Params = object
other: AActorPtr
returnValue: bool
var param = Params(other: other)
let fnName {.used.} = n "IsOverlappingActor"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isGravityEnabled*(self : UPrimitiveComponentPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsGravityEnabled"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isAnyRigidBodyAwake*(self : UPrimitiveComponentPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsAnyRigidBodyAwake"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc invalidateLumenSurfaceCache*(self : UPrimitiveComponentPtr): void {.
exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "InvalidateLumenSurfaceCache"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc ignoreComponentWhenMoving*(self : UPrimitiveComponentPtr;
component : UPrimitiveComponentPtr;
bShouldIgnore : bool): void {.
exportcpp: "$1_".} =
type
Params = object
component: UPrimitiveComponentPtr
bShouldIgnore: bool
var param = Params(component: component,
bShouldIgnore: bShouldIgnore)
let fnName {.used.} = n "IgnoreComponentWhenMoving"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc ignoreActorWhenMoving*(self : UPrimitiveComponentPtr;
actor : AActorPtr;
bShouldIgnore : bool): void {.
exportcpp: "$1_".} =
type
Params = object
actor: AActorPtr
bShouldIgnore: bool
var param = Params(actor: actor, bShouldIgnore: bShouldIgnore)
let fnName {.used.} = n "IgnoreActorWhenMoving"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc getWalkableSlopeOverride*(self : UPrimitiveComponentPtr): FWalkableSlopeOverride {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FWalkableSlopeOverride
var param = Params()
let fnName {.used.} = n "GetWalkableSlopeOverride"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getPhysicsLinearVelocityAtPoint*(self : UPrimitiveComponentPtr;
point : FVector;
boneName : FName = makeFName("None")): FVector {.exportcpp: "$1_".} =
type
Params = object
point: FVector
boneName: FName
returnValue: FVector
var param = Params(point: point, boneName: boneName)
let fnName {.used.} = n "GetPhysicsLinearVelocityAtPoint"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getPhysicsLinearVelocity*(self : UPrimitiveComponentPtr;
boneName : FName = makeFName("None")): FVector {.
exportcpp: "$1_".} =
type
Params = object
boneName: FName
returnValue: FVector
var param = Params(boneName: boneName)
let fnName {.used.} = n "GetPhysicsLinearVelocity"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getPhysicsAngularVelocityInRadians*(self : UPrimitiveComponentPtr;
boneName : FName = makeFName("None")): FVector {.exportcpp: "$1_".} =
type
Params = object
boneName: FName
returnValue: FVector
var param = Params(boneName: boneName)
let fnName {.used.} = n "GetPhysicsAngularVelocityInRadians"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getPhysicsAngularVelocityInDegrees*(self : UPrimitiveComponentPtr;
boneName : FName = makeFName("None")): FVector {.exportcpp: "$1_".} =
type
Params = object
boneName: FName
returnValue: FVector
var param = Params(boneName: boneName)
let fnName {.used.} = n "GetPhysicsAngularVelocityInDegrees"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getOverlappingComponents*(self : UPrimitiveComponentPtr;
outOverlappingComponents : var TArray[UPrimitiveComponentPtr]): void {.
exportcpp: "$1_".} =
type
Params = object
outOverlappingComponents: TArray[UPrimitiveComponentPtr]
var param = Params(outOverlappingComponents: outOverlappingComponents)
let fnName {.used.} = n "GetOverlappingComponents"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
outOverlappingComponents = param.outOverlappingComponents
proc getOverlappingActors*(self : UPrimitiveComponentPtr;
overlappingActors : var TArray[AActorPtr];
classFilter : TSubclassOf[AActor]): void {.
exportcpp: "$1_".} =
type
Params = object
overlappingActors: TArray[AActorPtr]
classFilter: TSubclassOf[AActor]
var param = Params(overlappingActors: overlappingActors,
classFilter: classFilter)
let fnName {.used.} = n "GetOverlappingActors"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
overlappingActors = param.overlappingActors
proc getNumMaterials*(self : UPrimitiveComponentPtr): int32 {.
exportcpp: "$1_".} =
type
Params = object
returnValue: int32
var param = Params()
let fnName {.used.} = n "GetNumMaterials"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getMaterialFromCollisionFaceIndex*(self : UPrimitiveComponentPtr;
faceIndex : int32;
sectionIndex : var int32): UMaterialInterfacePtr {.
exportcpp: "$1_".} =
type
Params = object
faceIndex: int32
sectionIndex: int32
returnValue: UMaterialInterfacePtr
var param = Params(faceIndex: faceIndex, sectionIndex: sectionIndex)
let fnName {.used.} = n "GetMaterialFromCollisionFaceIndex"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
sectionIndex = param.sectionIndex
return param.returnValue
proc getMaterial*(self : UPrimitiveComponentPtr;
elementIndex : int32): UMaterialInterfacePtr {.
exportcpp: "$1_".} =
type
Params = object
elementIndex: int32
returnValue: UMaterialInterfacePtr
var param = Params(elementIndex: elementIndex)
let fnName {.used.} = n "GetMaterial"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getMassScale*(self : UPrimitiveComponentPtr;
boneName : FName = makeFName("None")): float32 {.
exportcpp: "$1_".} =
type
Params = object
boneName: FName
returnValue: float32
var param = Params(boneName: boneName)
let fnName {.used.} = n "GetMassScale"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getMass*(self : UPrimitiveComponentPtr): float32 {.
exportcpp: "$1_".} =
type
Params = object
returnValue: float32
var param = Params()
let fnName {.used.} = n "GetMass"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getLinearDamping*(self : UPrimitiveComponentPtr): float32 {.
exportcpp: "$1_".} =
type
Params = object
returnValue: float32
var param = Params()
let fnName {.used.} = n "GetLinearDamping"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getInertiaTensor*(self : UPrimitiveComponentPtr;
boneName : FName = makeFName("None")): FVector {.
exportcpp: "$1_".} =
type
Params = object
boneName: FName
returnValue: FVector
var param = Params(boneName: boneName)
let fnName {.used.} = n "GetInertiaTensor"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getGenerateOverlapEvents*(self : UPrimitiveComponentPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "GetGenerateOverlapEvents"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getCustomPrimitiveDataIndexForVectorParameter*(
self : UPrimitiveComponentPtr; parameterName : FName): int32 {.
exportcpp: "$1_".} =
type
Params = object
parameterName: FName
returnValue: int32
var param = Params(parameterName: parameterName)
let fnName {.used.} = n "GetCustomPrimitiveDataIndexForVectorParameter"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getCustomPrimitiveDataIndexForScalarParameter*(
self : UPrimitiveComponentPtr; parameterName : FName): int32 {.
exportcpp: "$1_".} =
type
Params = object
parameterName: FName
returnValue: int32
var param = Params(parameterName: parameterName)
let fnName {.used.} = n "GetCustomPrimitiveDataIndexForScalarParameter"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getCollisionResponseToChannel*(self : UPrimitiveComponentPtr;
channel : ECollisionChannel): ECollisionResponse {.
exportcpp: "$1_".} =
type
Params = object
channel: ECollisionChannel
returnValue: ECollisionResponse
var param = Params(channel: channel)
let fnName {.used.} = n "GetCollisionResponseToChannel"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getCollisionProfileName*(self : UPrimitiveComponentPtr): FName {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FName
var param = Params()
let fnName {.used.} = n "GetCollisionProfileName"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getCollisionObjectType*(self : UPrimitiveComponentPtr): ECollisionChannel {.
exportcpp: "$1_".} =
type
Params = object
returnValue: ECollisionChannel
var param = Params()
let fnName {.used.} = n "GetCollisionObjectType"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getCollisionEnabled*(self : UPrimitiveComponentPtr): ECollisionEnabled {.
exportcpp: "$1_".} =
type
Params = object
returnValue: ECollisionEnabled
var param = Params()
let fnName {.used.} = n "GetCollisionEnabled"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getClosestPointOnCollision*(self : UPrimitiveComponentPtr;
point : var FVector;
outPointOnBody : var FVector;
boneName : FName = makeFName("None")): float32 {.
exportcpp: "$1_".} =
type
Params = object
point: FVector
outPointOnBody: FVector
boneName: FName
returnValue: float32
var param = Params(point: point, outPointOnBody: outPointOnBody,
boneName: boneName)
let fnName {.used.} = n "GetClosestPointOnCollision"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
point = param.point
outPointOnBody = param.outPointOnBody
return param.returnValue
proc getCenterOfMass*(self : UPrimitiveComponentPtr;
boneName : FName = makeFName("None")): FVector {.
exportcpp: "$1_".} =
type
Params = object
boneName: FName
returnValue: FVector
var param = Params(boneName: boneName)
let fnName {.used.} = n "GetCenterOfMass"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getBodyInstanceAsyncPhysicsTickHandle*(
self : UPrimitiveComponentPtr;
boneName : FName = makeFName("None");
bGetWelded : bool = true; index : int32 = -1'i32): FBodyInstanceAsyncPhysicsTickHandle {.
exportcpp: "$1_".} =
type
Params = object
boneName: FName
bGetWelded: bool
index: int32
returnValue: FBodyInstanceAsyncPhysicsTickHandle
var param = Params(boneName: boneName, bGetWelded: bGetWelded,
index: index)
let fnName {.used.} = n "GetBodyInstanceAsyncPhysicsTickHandle"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getAngularDamping*(self : UPrimitiveComponentPtr): float32 {.
exportcpp: "$1_".} =
type
Params = object
returnValue: float32
var param = Params()
let fnName {.used.} = n "GetAngularDamping"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc createDynamicMaterialInstance*(self : UPrimitiveComponentPtr;
elementIndex : int32;
sourceMaterial : UMaterialInterfacePtr = nil;
optionalName : FName = makeFName("None")): UMaterialInstanceDynamicPtr {.
exportcpp: "$1_".} =
type
Params = object
elementIndex: int32
sourceMaterial: UMaterialInterfacePtr
optionalName: FName
returnValue: UMaterialInstanceDynamicPtr
var param = Params(elementIndex: elementIndex,
sourceMaterial: sourceMaterial,
optionalName: optionalName)
let fnName {.used.} = n "CreateDynamicMaterialInstance"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc createAndSetMaterialInstanceDynamicFromMaterial*(
self : UPrimitiveComponentPtr; elementIndex : int32;
parent : UMaterialInterfacePtr): UMaterialInstanceDynamicPtr {.
exportcpp: "$1_".} =
type
Params = object
elementIndex: int32
parent: UMaterialInterfacePtr
returnValue: UMaterialInstanceDynamicPtr
var param = Params(elementIndex: elementIndex, parent: parent)
let fnName {.used.} = n "CreateAndSetMaterialInstanceDynamicFromMaterial"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc createAndSetMaterialInstanceDynamic*(
self : UPrimitiveComponentPtr; elementIndex : int32): UMaterialInstanceDynamicPtr {.
exportcpp: "$1_".} =
type
Params = object
elementIndex: int32
returnValue: UMaterialInstanceDynamicPtr
var param = Params(elementIndex: elementIndex)
let fnName {.used.} = n "CreateAndSetMaterialInstanceDynamic"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc copyArrayOfMoveIgnoreComponents*(self : UPrimitiveComponentPtr): TArray[
UPrimitiveComponentPtr] {.exportcpp: "$1_".} =
type
Params = object
returnValue: TArray[UPrimitiveComponentPtr]
var param = Params()
let fnName {.used.} = n "CopyArrayOfMoveIgnoreComponents"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc copyArrayOfMoveIgnoreActors*(self : UPrimitiveComponentPtr): TArray[
AActorPtr] {.exportcpp: "$1_".} =
type
Params = object
returnValue: TArray[AActorPtr]
var param = Params()
let fnName {.used.} = n "CopyArrayOfMoveIgnoreActors"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc clearMoveIgnoreComponents*(self : UPrimitiveComponentPtr): void {.
exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "ClearMoveIgnoreComponents"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc clearMoveIgnoreActors*(self : UPrimitiveComponentPtr): void {.
exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "ClearMoveIgnoreActors"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc canCharacterStepUp*(self : UPrimitiveComponentPtr;
pawn : APawnPtr): bool {.exportcpp: "$1_".} =
type
Params = object
pawn: APawnPtr
returnValue: bool
var param = Params(pawn: pawn)
let fnName {.used.} = n "CanCharacterStepUp"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc addVelocityChangeImpulseAtLocation*(self : UPrimitiveComponentPtr;
impulse : FVector; location : FVector;
boneName : FName = makeFName("None")): void {.exportcpp: "$1_".} =
type
Params = object
impulse: FVector
location: FVector
boneName: FName
var param = Params(impulse: impulse, location: location,
boneName: boneName)
let fnName {.used.} = n "AddVelocityChangeImpulseAtLocation"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc addTorqueInRadians*(self : UPrimitiveComponentPtr;
torque : FVector;
boneName : FName = makeFName("None");
bAccelChange : bool = false): void {.
exportcpp: "$1_".} =
type
Params = object
torque: FVector
boneName: FName
bAccelChange: bool
var param = Params(torque: torque, boneName: boneName,
bAccelChange: bAccelChange)
let fnName {.used.} = n "AddTorqueInRadians"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc addTorqueInDegrees*(self : UPrimitiveComponentPtr;
torque : FVector;
boneName : FName = makeFName("None");
bAccelChange : bool = false): void {.
exportcpp: "$1_".} =
type
Params = object
torque: FVector
boneName: FName
bAccelChange: bool
var param = Params(torque: torque, boneName: boneName,
bAccelChange: bAccelChange)
let fnName {.used.} = n "AddTorqueInDegrees"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc addRadialImpulse*(self : UPrimitiveComponentPtr;
origin : FVector; radius : float32;
strength : float32;
falloff : ERadialImpulseFalloff;
bVelChange : bool = false): void {.
exportcpp: "$1_".} =
type
Params = object
origin: FVector
radius: float32
strength: float32
falloff: ERadialImpulseFalloff
bVelChange: bool
var param = Params(origin: origin, radius: radius,
strength: strength, falloff: falloff,
bVelChange: bVelChange)
let fnName {.used.} = n "AddRadialImpulse"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc addRadialForce*(self : UPrimitiveComponentPtr;
origin : FVector; radius : float32;
strength : float32;
falloff : ERadialImpulseFalloff;
bAccelChange : bool = false): void {.
exportcpp: "$1_".} =
type
Params = object
origin: FVector
radius: float32
strength: float32
falloff: ERadialImpulseFalloff
bAccelChange: bool
var param = Params(origin: origin, radius: radius,
strength: strength, falloff: falloff,
bAccelChange: bAccelChange)
let fnName {.used.} = n "AddRadialForce"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc addImpulseAtLocation*(self : UPrimitiveComponentPtr;
impulse : FVector;
location : FVector;
boneName : FName = makeFName("None")): void {.
exportcpp: "$1_".} =
type
Params = object
impulse: FVector
location: FVector
boneName: FName
var param = Params(impulse: impulse, location: location,
boneName: boneName)
let fnName {.used.} = n "AddImpulseAtLocation"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc addImpulse*(self : UPrimitiveComponentPtr;
impulse : FVector;
boneName : FName = makeFName("None");
bVelChange : bool = false): void {.exportcpp: "$1_".} =
type
Params = object
impulse: FVector
boneName: FName
bVelChange: bool
var param = Params(impulse: impulse, boneName: boneName,
bVelChange: bVelChange)
let fnName {.used.} = n "AddImpulse"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc addForceAtLocationLocal*(self : UPrimitiveComponentPtr;
force : FVector;
location : FVector;
boneName : FName = makeFName("None")): void {.
exportcpp: "$1_".} =
type
Params = object
force: FVector
location: FVector
boneName: FName
var param = Params(force: force, location: location,
boneName: boneName)
let fnName {.used.} = n "AddForceAtLocationLocal"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc addForceAtLocation*(self : UPrimitiveComponentPtr;
force : FVector; location : FVector;
boneName : FName = makeFName("None")): void {.
exportcpp: "$1_".} =
type
Params = object
force: FVector
location: FVector
boneName: FName
var param = Params(force: force, location: location,
boneName: boneName)
let fnName {.used.} = n "AddForceAtLocation"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc addForce*(self : UPrimitiveComponentPtr;
force : FVector;
boneName : FName = makeFName("None");
bAccelChange : bool = false): void {.exportcpp: "$1_".} =
type
Params = object
force: FVector
boneName: FName
bAccelChange: bool
var param = Params(force: force, boneName: boneName,
bAccelChange: bAccelChange)
let fnName {.used.} = n "AddForce"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc addAngularImpulseInRadians*(self : UPrimitiveComponentPtr;
impulse : FVector;
boneName : FName = makeFName("None");
bVelChange : bool = false): void {.
exportcpp: "$1_".} =
type
Params = object
impulse: FVector
boneName: FName
bVelChange: bool
var param = Params(impulse: impulse, boneName: boneName,
bVelChange: bVelChange)
let fnName {.used.} = n "AddAngularImpulseInRadians"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc addAngularImpulseInDegrees*(self : UPrimitiveComponentPtr;
impulse : FVector;
boneName : FName = makeFName("None");
bVelChange : bool = false): void {.
exportcpp: "$1_".} =
type
Params = object
impulse: FVector
boneName: FName
bVelChange: bool
var param = Params(impulse: impulse, boneName: boneName,
bVelChange: bVelChange)
let fnName {.used.} = n "AddAngularImpulseInDegrees"
let fn {.used.} = getClassByName("PrimitiveComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc keepUPrimitiveComponent(fake : UPrimitiveComponent) {.exportcpp.} =
discard
converter UPrimitiveComponenttoUNavRelevantInterface*(
self : UPrimitiveComponentPtr): UNavRelevantInterfacePtr =
cast[UNavRelevantInterfacePtr](self)
converter UPrimitiveComponenttoUInterface_AsyncCompilation*(
self : UPrimitiveComponentPtr): UInterface_AsyncCompilationPtr =
cast[UInterface_AsyncCompilationPtr](self)
proc `overlayMaterial`*(obj : UMeshComponentPtr): UMaterialInterfacePtr {.
exportcpp.} =
let prop = getClassByName("MeshComponent").getFPropertyByName(
"OverlayMaterial")
getPropertyValuePtr[UMaterialInterfacePtr](prop, obj)[]
proc `overlayMaterial=`*(obj : UMeshComponentPtr;
val : UMaterialInterfacePtr) =
var value : UMaterialInterfacePtr = val
let prop = getClassByName("MeshComponent").getFPropertyByName(
"OverlayMaterial")
setPropertyValuePtr[UMaterialInterfacePtr](prop, obj, value.addr)
proc `set overlayMaterial`*(obj : UMeshComponentPtr;
val : UMaterialInterfacePtr) {.exportcpp.} =
var value : UMaterialInterfacePtr = val
let prop = getClassByName("MeshComponent").getFPropertyByName(
"OverlayMaterial")
setPropertyValuePtr[UMaterialInterfacePtr](prop, obj, value.addr)
proc `overlayMaterialMaxDrawDistance`*(obj : UMeshComponentPtr): float32 {.
exportcpp.} =
let prop = getClassByName("MeshComponent").getFPropertyByName(
"OverlayMaterialMaxDrawDistance")
getPropertyValuePtr[float32](prop, obj)[]
proc `overlayMaterialMaxDrawDistance=`*(obj : UMeshComponentPtr;
val : float32) =
var value : float32 = val
let prop = getClassByName("MeshComponent").getFPropertyByName(
"OverlayMaterialMaxDrawDistance")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set overlayMaterialMaxDrawDistance`*(obj : UMeshComponentPtr;
val : float32) {.exportcpp.} =
var value : float32 = val
let prop = getClassByName("MeshComponent").getFPropertyByName(
"OverlayMaterialMaxDrawDistance")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `bEnableMaterialParameterCaching`*(obj : UMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("MeshComponent").getFPropertyByName(
"bEnableMaterialParameterCaching")
getValueFromBoolProp(prop, obj)
proc `bEnableMaterialParameterCaching=`*(obj : UMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("MeshComponent").getFPropertyByName(
"bEnableMaterialParameterCaching")
setValueInBoolProp(prop, obj, value)
proc `set bEnableMaterialParameterCaching`*(obj : UMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("MeshComponent").getFPropertyByName(
"bEnableMaterialParameterCaching")
setValueInBoolProp(prop, obj, value)
proc setVectorParameterValueOnMaterials*(self : UMeshComponentPtr;
parameterName : FName; parameterValue : FVector): void {.
exportcpp: "$1_".} =
type
Params = object
parameterName: FName
parameterValue: FVector
var param = Params(parameterName: parameterName,
parameterValue: parameterValue)
let fnName {.used.} = n "SetVectorParameterValueOnMaterials"
let fn {.used.} = getClassByName("MeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setScalarParameterValueOnMaterials*(self : UMeshComponentPtr;
parameterName : FName; parameterValue : float32): void {.
exportcpp: "$1_".} =
type
Params = object
parameterName: FName
parameterValue: float32
var param = Params(parameterName: parameterName,
parameterValue: parameterValue)
let fnName {.used.} = n "SetScalarParameterValueOnMaterials"
let fn {.used.} = getClassByName("MeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setOverlayMaterialMaxDrawDistance*(self : UMeshComponentPtr;
inMaxDrawDistance : float32): void {.
exportcpp: "$1_".} =
type
Params = object
inMaxDrawDistance: float32
var param = Params(inMaxDrawDistance: inMaxDrawDistance)
let fnName {.used.} = n "SetOverlayMaterialMaxDrawDistance"
let fn {.used.} = getClassByName("MeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setOverlayMaterial*(self : UMeshComponentPtr;
newOverlayMaterial : UMaterialInterfacePtr): void {.
exportcpp: "$1_".} =
type
Params = object
newOverlayMaterial: UMaterialInterfacePtr
var param = Params(newOverlayMaterial: newOverlayMaterial)
let fnName {.used.} = n "SetOverlayMaterial"
let fn {.used.} = getClassByName("MeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc prestreamTextures*(self : UMeshComponentPtr;
seconds : float32;
bPrioritizeCharacterTextures : bool;
cinematicTextureGroups : int32 = 0'i32): void {.
exportcpp: "$1_".} =
type
Params = object
seconds: float32
bPrioritizeCharacterTextures: bool
cinematicTextureGroups: int32
var param = Params(seconds: seconds, bPrioritizeCharacterTextures: bPrioritizeCharacterTextures,
cinematicTextureGroups: cinematicTextureGroups)
let fnName {.used.} = n "PrestreamTextures"
let fn {.used.} = getClassByName("MeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc isMaterialSlotNameValid*(self : UMeshComponentPtr;
materialSlotName : FName): bool {.
exportcpp: "$1_".} =
type
Params = object
materialSlotName: FName
returnValue: bool
var param = Params(materialSlotName: materialSlotName)
let fnName {.used.} = n "IsMaterialSlotNameValid"
let fn {.used.} = getClassByName("MeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getOverlayMaterial*(self : UMeshComponentPtr): UMaterialInterfacePtr {.
exportcpp: "$1_".} =
type
Params = object
returnValue: UMaterialInterfacePtr
var param = Params()
let fnName {.used.} = n "GetOverlayMaterial"
let fn {.used.} = getClassByName("MeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getMaterialSlotNames*(self : UMeshComponentPtr): TArray[FName] {.
exportcpp: "$1_".} =
type
Params = object
returnValue: TArray[FName]
var param = Params()
let fnName {.used.} = n "GetMaterialSlotNames"
let fn {.used.} = getClassByName("MeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getMaterials*(self : UMeshComponentPtr): TArray[
UMaterialInterfacePtr] {.exportcpp: "$1_".} =
type
Params = object
returnValue: TArray[UMaterialInterfacePtr]
var param = Params()
let fnName {.used.} = n "GetMaterials"
let fn {.used.} = getClassByName("MeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getMaterialIndex*(self : UMeshComponentPtr;
materialSlotName : FName): int32 {.
exportcpp: "$1_".} =
type
Params = object
materialSlotName: FName
returnValue: int32
var param = Params(materialSlotName: materialSlotName)
let fnName {.used.} = n "GetMaterialIndex"
let fn {.used.} = getClassByName("MeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc keepUMeshComponent(fake : UMeshComponent) {.exportcpp.} =
discard
proc activate*(self : UBlueprintAsyncActionBasePtr): void {.
exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "Activate"
let fn {.used.} = getClassByName("BlueprintAsyncActionBase").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc keepUBlueprintAsyncActionBase(fake : UBlueprintAsyncActionBase) {.
exportcpp.} =
discard
proc keepAInfo(fake : AInfo) {.exportcpp.} =
discard
proc `optionsString`*(obj : AGameModeBasePtr): FString {.exportcpp.} =
let prop = getClassByName("GameModeBase").getFPropertyByName(
"OptionsString")
getPropertyValuePtr[FString](prop, obj)[]
proc `optionsString=`*(obj : AGameModeBasePtr; val : FString) =
var value : FString = val
let prop = getClassByName("GameModeBase").getFPropertyByName(
"OptionsString")
setPropertyValuePtr[FString](prop, obj, value.addr)
proc `set optionsString`*(obj : AGameModeBasePtr;
val : FString) {.exportcpp.} =
var value : FString = val
let prop = getClassByName("GameModeBase").getFPropertyByName(
"OptionsString")
setPropertyValuePtr[FString](prop, obj, value.addr)
proc `gameSessionClass`*(obj : AGameModeBasePtr): TSubclassOf[
AGameSession] {.exportcpp.} =
let prop = getClassByName("GameModeBase").getFPropertyByName(
"GameSessionClass")
getPropertyValuePtr[TSubclassOf[AGameSession]](prop, obj)[]
proc `gameSessionClass=`*(obj : AGameModeBasePtr;
val : TSubclassOf[AGameSession]) =
var value : TSubclassOf[AGameSession] = val
let prop = getClassByName("GameModeBase").getFPropertyByName(
"GameSessionClass")
setPropertyValuePtr[TSubclassOf[AGameSession]](prop, obj, value.addr)
proc `set gameSessionClass`*(obj : AGameModeBasePtr;
val : TSubclassOf[AGameSession]) {.
exportcpp.} =
var value : TSubclassOf[AGameSession] = val
let prop = getClassByName("GameModeBase").getFPropertyByName(
"GameSessionClass")
setPropertyValuePtr[TSubclassOf[AGameSession]](prop, obj, value.addr)
proc `gameStateClass`*(obj : AGameModeBasePtr): TSubclassOf[
AGameStateBase] {.exportcpp.} =
let prop = getClassByName("GameModeBase").getFPropertyByName(
"GameStateClass")
getPropertyValuePtr[TSubclassOf[AGameStateBase]](prop, obj)[]
proc `gameStateClass=`*(obj : AGameModeBasePtr;
val : TSubclassOf[AGameStateBase]) =
var value : TSubclassOf[AGameStateBase] = val
let prop = getClassByName("GameModeBase").getFPropertyByName(
"GameStateClass")
setPropertyValuePtr[TSubclassOf[AGameStateBase]](prop, obj, value.addr)
proc `set gameStateClass`*(obj : AGameModeBasePtr;
val : TSubclassOf[AGameStateBase]) {.
exportcpp.} =
var value : TSubclassOf[AGameStateBase] = val
let prop = getClassByName("GameModeBase").getFPropertyByName(
"GameStateClass")
setPropertyValuePtr[TSubclassOf[AGameStateBase]](prop, obj, value.addr)
proc `playerControllerClass`*(obj : AGameModeBasePtr): TSubclassOf[
APlayerController] {.exportcpp.} =
let prop = getClassByName("GameModeBase").getFPropertyByName(
"PlayerControllerClass")
getPropertyValuePtr[TSubclassOf[APlayerController]](prop, obj)[]
proc `playerControllerClass=`*(obj : AGameModeBasePtr;
val : TSubclassOf[APlayerController]) =
var value : TSubclassOf[APlayerController] = val
let prop = getClassByName("GameModeBase").getFPropertyByName(
"PlayerControllerClass")
setPropertyValuePtr[TSubclassOf[APlayerController]](prop, obj, value.addr)
proc `set playerControllerClass`*(obj : AGameModeBasePtr;
val : TSubclassOf[APlayerController]) {.
exportcpp.} =
var value : TSubclassOf[APlayerController] = val
let prop = getClassByName("GameModeBase").getFPropertyByName(
"PlayerControllerClass")
setPropertyValuePtr[TSubclassOf[APlayerController]](prop, obj, value.addr)
proc `playerStateClass`*(obj : AGameModeBasePtr): TSubclassOf[
APlayerState] {.exportcpp.} =
let prop = getClassByName("GameModeBase").getFPropertyByName(
"PlayerStateClass")
getPropertyValuePtr[TSubclassOf[APlayerState]](prop, obj)[]
proc `playerStateClass=`*(obj : AGameModeBasePtr;
val : TSubclassOf[APlayerState]) =
var value : TSubclassOf[APlayerState] = val
let prop = getClassByName("GameModeBase").getFPropertyByName(
"PlayerStateClass")
setPropertyValuePtr[TSubclassOf[APlayerState]](prop, obj, value.addr)
proc `set playerStateClass`*(obj : AGameModeBasePtr;
val : TSubclassOf[APlayerState]) {.
exportcpp.} =
var value : TSubclassOf[APlayerState] = val
let prop = getClassByName("GameModeBase").getFPropertyByName(
"PlayerStateClass")
setPropertyValuePtr[TSubclassOf[APlayerState]](prop, obj, value.addr)
proc `hUDClass`*(obj : AGameModeBasePtr): TSubclassOf[AHUD] {.
exportcpp.} =
let prop = getClassByName("GameModeBase").getFPropertyByName(
"HUDClass")
getPropertyValuePtr[TSubclassOf[AHUD]](prop, obj)[]
proc `hUDClass=`*(obj : AGameModeBasePtr;
val : TSubclassOf[AHUD]) =
var value : TSubclassOf[AHUD] = val
let prop = getClassByName("GameModeBase").getFPropertyByName(
"HUDClass")
setPropertyValuePtr[TSubclassOf[AHUD]](prop, obj, value.addr)
proc `set hUDClass`*(obj : AGameModeBasePtr;
val : TSubclassOf[AHUD]) {.exportcpp.} =
var value : TSubclassOf[AHUD] = val
let prop = getClassByName("GameModeBase").getFPropertyByName(
"HUDClass")
setPropertyValuePtr[TSubclassOf[AHUD]](prop, obj, value.addr)
proc `defaultPawnClass`*(obj : AGameModeBasePtr): TSubclassOf[APawn] {.
exportcpp.} =
let prop = getClassByName("GameModeBase").getFPropertyByName(
"DefaultPawnClass")
getPropertyValuePtr[TSubclassOf[APawn]](prop, obj)[]
proc `defaultPawnClass=`*(obj : AGameModeBasePtr;
val : TSubclassOf[APawn]) =
var value : TSubclassOf[APawn] = val
let prop = getClassByName("GameModeBase").getFPropertyByName(
"DefaultPawnClass")
setPropertyValuePtr[TSubclassOf[APawn]](prop, obj, value.addr)
proc `set defaultPawnClass`*(obj : AGameModeBasePtr;
val : TSubclassOf[APawn]) {.exportcpp.} =
var value : TSubclassOf[APawn] = val
let prop = getClassByName("GameModeBase").getFPropertyByName(
"DefaultPawnClass")
setPropertyValuePtr[TSubclassOf[APawn]](prop, obj, value.addr)
proc `spectatorClass`*(obj : AGameModeBasePtr): TSubclassOf[
ASpectatorPawn] {.exportcpp.} =
let prop = getClassByName("GameModeBase").getFPropertyByName(
"SpectatorClass")
getPropertyValuePtr[TSubclassOf[ASpectatorPawn]](prop, obj)[]
proc `spectatorClass=`*(obj : AGameModeBasePtr;
val : TSubclassOf[ASpectatorPawn]) =
var value : TSubclassOf[ASpectatorPawn] = val
let prop = getClassByName("GameModeBase").getFPropertyByName(
"SpectatorClass")
setPropertyValuePtr[TSubclassOf[ASpectatorPawn]](prop, obj, value.addr)
proc `set spectatorClass`*(obj : AGameModeBasePtr;
val : TSubclassOf[ASpectatorPawn]) {.
exportcpp.} =
var value : TSubclassOf[ASpectatorPawn] = val
let prop = getClassByName("GameModeBase").getFPropertyByName(
"SpectatorClass")
setPropertyValuePtr[TSubclassOf[ASpectatorPawn]](prop, obj, value.addr)
proc `replaySpectatorPlayerControllerClass`*(obj : AGameModeBasePtr): TSubclassOf[
APlayerController] {.exportcpp.} =
let prop = getClassByName("GameModeBase").getFPropertyByName(
"ReplaySpectatorPlayerControllerClass")
getPropertyValuePtr[TSubclassOf[APlayerController]](prop, obj)[]
proc `replaySpectatorPlayerControllerClass=`*(obj : AGameModeBasePtr;
val : TSubclassOf[APlayerController]) =
var value : TSubclassOf[APlayerController] = val
let prop = getClassByName("GameModeBase").getFPropertyByName(
"ReplaySpectatorPlayerControllerClass")
setPropertyValuePtr[TSubclassOf[APlayerController]](prop, obj, value.addr)
proc `set replaySpectatorPlayerControllerClass`*(
obj : AGameModeBasePtr;
val : TSubclassOf[APlayerController]) {.exportcpp.} =
var value : TSubclassOf[APlayerController] = val
let prop = getClassByName("GameModeBase").getFPropertyByName(
"ReplaySpectatorPlayerControllerClass")
setPropertyValuePtr[TSubclassOf[APlayerController]](prop, obj, value.addr)
proc `serverStatReplicatorClass`*(obj : AGameModeBasePtr): TSubclassOf[
AServerStatReplicator] {.exportcpp.} =
let prop = getClassByName("GameModeBase").getFPropertyByName(
"ServerStatReplicatorClass")
getPropertyValuePtr[TSubclassOf[AServerStatReplicator]](prop, obj)[]
proc `serverStatReplicatorClass=`*(obj : AGameModeBasePtr;
val : TSubclassOf[AServerStatReplicator]) =
var value : TSubclassOf[AServerStatReplicator] = val
let prop = getClassByName("GameModeBase").getFPropertyByName(
"ServerStatReplicatorClass")
setPropertyValuePtr[TSubclassOf[AServerStatReplicator]](prop, obj, value.addr)
proc `set serverStatReplicatorClass`*(obj : AGameModeBasePtr;
val : TSubclassOf[AServerStatReplicator]) {.exportcpp.} =
var value : TSubclassOf[AServerStatReplicator] = val
let prop = getClassByName("GameModeBase").getFPropertyByName(
"ServerStatReplicatorClass")
setPropertyValuePtr[TSubclassOf[AServerStatReplicator]](prop, obj, value.addr)
proc `bUseSeamlessTravel`*(obj : AGameModeBasePtr): bool {.exportcpp.} =
let prop = getClassByName("GameModeBase").getFPropertyByName(
"bUseSeamlessTravel")
getValueFromBoolProp(prop, obj)
proc `bUseSeamlessTravel=`*(obj : AGameModeBasePtr;
val : bool) =
var value : bool = val
let prop = getClassByName("GameModeBase").getFPropertyByName(
"bUseSeamlessTravel")
setValueInBoolProp(prop, obj, value)
proc `set bUseSeamlessTravel`*(obj : AGameModeBasePtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("GameModeBase").getFPropertyByName(
"bUseSeamlessTravel")
setValueInBoolProp(prop, obj, value)
proc `bStartPlayersAsSpectators`*(obj : AGameModeBasePtr): bool {.
exportcpp.} =
let prop = getClassByName("GameModeBase").getFPropertyByName(
"bStartPlayersAsSpectators")
getValueFromBoolProp(prop, obj)
proc `bStartPlayersAsSpectators=`*(obj : AGameModeBasePtr;
val : bool) =
var value : bool = val
let prop = getClassByName("GameModeBase").getFPropertyByName(
"bStartPlayersAsSpectators")
setValueInBoolProp(prop, obj, value)
proc `set bStartPlayersAsSpectators`*(obj : AGameModeBasePtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("GameModeBase").getFPropertyByName(
"bStartPlayersAsSpectators")
setValueInBoolProp(prop, obj, value)
proc `bPauseable`*(obj : AGameModeBasePtr): bool {.exportcpp.} =
let prop = getClassByName("GameModeBase").getFPropertyByName(
"bPauseable")
getValueFromBoolProp(prop, obj)
proc `bPauseable=`*(obj : AGameModeBasePtr; val : bool) =
var value : bool = val
let prop = getClassByName("GameModeBase").getFPropertyByName(
"bPauseable")
setValueInBoolProp(prop, obj, value)
proc `set bPauseable`*(obj : AGameModeBasePtr; val : bool) {.
exportcpp.} =
var value : bool = val
let prop = getClassByName("GameModeBase").getFPropertyByName(
"bPauseable")
setValueInBoolProp(prop, obj, value)
proc startPlay*(self : AGameModeBasePtr): void {.exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "StartPlay"
let fn {.used.} = getClassByName("GameModeBase").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc returnToMainMenuHost*(self : AGameModeBasePtr): void {.
exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "ReturnToMainMenuHost"
let fn {.used.} = getClassByName("GameModeBase").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc restartPlayerAtTransform*(self : AGameModeBasePtr;
newPlayer : AControllerPtr;
spawnTransform : var FTransform): void {.
exportcpp: "$1_".} =
type
Params = object
newPlayer: AControllerPtr
spawnTransform: FTransform
var param = Params(newPlayer: newPlayer,
spawnTransform: spawnTransform)
let fnName {.used.} = n "RestartPlayerAtTransform"
let fn {.used.} = getClassByName("GameModeBase").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
spawnTransform = param.spawnTransform
proc restartPlayerAtPlayerStart*(self : AGameModeBasePtr;
newPlayer : AControllerPtr;
startSpot : AActorPtr): void {.
exportcpp: "$1_".} =
type
Params = object
newPlayer: AControllerPtr
startSpot: AActorPtr
var param = Params(newPlayer: newPlayer, startSpot: startSpot)
let fnName {.used.} = n "RestartPlayerAtPlayerStart"
let fn {.used.} = getClassByName("GameModeBase").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc restartPlayer*(self : AGameModeBasePtr;
newPlayer : AControllerPtr): void {.
exportcpp: "$1_".} =
type
Params = object
newPlayer: AControllerPtr
var param = Params(newPlayer: newPlayer)
let fnName {.used.} = n "RestartPlayer"
let fn {.used.} = getClassByName("GameModeBase").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc resetLevel*(self : AGameModeBasePtr): void {.exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "ResetLevel"
let fn {.used.} = getClassByName("GameModeBase").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc playerCanRestart*(self : AGameModeBasePtr;
player : APlayerControllerPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
player: APlayerControllerPtr
returnValue: bool
var param = Params(player: player)
let fnName {.used.} = n "PlayerCanRestart"
let fn {.used.} = getClassByName("GameModeBase").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc k2_FindPlayerStart*(self : AGameModeBasePtr;
player : AControllerPtr;
incomingName : FString): AActorPtr {.
exportcpp: "$1_".} =
type
Params = object
player: AControllerPtr
incomingName: FString
returnValue: AActorPtr
var param = Params(player: player, incomingName: incomingName)
let fnName {.used.} = n "K2_FindPlayerStart"
let fn {.used.} = getClassByName("GameModeBase").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc hasMatchStarted*(self : AGameModeBasePtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "HasMatchStarted"
let fn {.used.} = getClassByName("GameModeBase").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc hasMatchEnded*(self : AGameModeBasePtr): bool {.exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "HasMatchEnded"
let fn {.used.} = getClassByName("GameModeBase").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getNumSpectators*(self : AGameModeBasePtr): int32 {.
exportcpp: "$1_".} =
type
Params = object
returnValue: int32
var param = Params()
let fnName {.used.} = n "GetNumSpectators"
let fn {.used.} = getClassByName("GameModeBase").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getNumPlayers*(self : AGameModeBasePtr): int32 {.exportcpp: "$1_".} =
type
Params = object
returnValue: int32
var param = Params()
let fnName {.used.} = n "GetNumPlayers"
let fn {.used.} = getClassByName("GameModeBase").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getDefaultPawnClassForController*(self : AGameModeBasePtr;
inController : AControllerPtr): UClassPtr {.
exportcpp: "$1_".} =
type
Params = object
inController: AControllerPtr
returnValue: UClassPtr
var param = Params(inController: inController)
let fnName {.used.} = n "GetDefaultPawnClassForController"
let fn {.used.} = getClassByName("GameModeBase").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc changeName*(self : AGameModeBasePtr;
controller : AControllerPtr;
newName : FString; bNameChange : bool): void {.
exportcpp: "$1_".} =
type
Params = object
controller: AControllerPtr
newName: FString
bNameChange: bool
var param = Params(controller: controller, newName: newName,
bNameChange: bNameChange)
let fnName {.used.} = n "ChangeName"
let fn {.used.} = getClassByName("GameModeBase").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc keepAGameModeBase(fake : AGameModeBase) {.exportcpp.} =
discard
proc `bDelayedStart`*(obj : AGameModePtr): bool {.exportcpp.} =
let prop = getClassByName("GameMode").getFPropertyByName(
"bDelayedStart")
getValueFromBoolProp(prop, obj)
proc `bDelayedStart=`*(obj : AGameModePtr; val : bool) =
var value : bool = val
let prop = getClassByName("GameMode").getFPropertyByName(
"bDelayedStart")
setValueInBoolProp(prop, obj, value)
proc `set bDelayedStart`*(obj : AGameModePtr; val : bool) {.
exportcpp.} =
var value : bool = val
let prop = getClassByName("GameMode").getFPropertyByName(
"bDelayedStart")
setValueInBoolProp(prop, obj, value)
proc `numSpectators`*(obj : AGameModePtr): int32 {.exportcpp.} =
let prop = getClassByName("GameMode").getFPropertyByName(
"NumSpectators")
getPropertyValuePtr[int32](prop, obj)[]
proc `numSpectators=`*(obj : AGameModePtr; val : int32) =
var value : int32 = val
let prop = getClassByName("GameMode").getFPropertyByName(
"NumSpectators")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `set numSpectators`*(obj : AGameModePtr; val : int32) {.
exportcpp.} =
var value : int32 = val
let prop = getClassByName("GameMode").getFPropertyByName(
"NumSpectators")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `numPlayers`*(obj : AGameModePtr): int32 {.exportcpp.} =
let prop = getClassByName("GameMode").getFPropertyByName(
"NumPlayers")
getPropertyValuePtr[int32](prop, obj)[]
proc `numPlayers=`*(obj : AGameModePtr; val : int32) =
var value : int32 = val
let prop = getClassByName("GameMode").getFPropertyByName(
"NumPlayers")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `set numPlayers`*(obj : AGameModePtr; val : int32) {.
exportcpp.} =
var value : int32 = val
let prop = getClassByName("GameMode").getFPropertyByName(
"NumPlayers")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `numBots`*(obj : AGameModePtr): int32 {.exportcpp.} =
let prop = getClassByName("GameMode").getFPropertyByName("NumBots")
getPropertyValuePtr[int32](prop, obj)[]
proc `numBots=`*(obj : AGameModePtr; val : int32) =
var value : int32 = val
let prop = getClassByName("GameMode").getFPropertyByName("NumBots")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `set numBots`*(obj : AGameModePtr; val : int32) {.
exportcpp.} =
var value : int32 = val
let prop = getClassByName("GameMode").getFPropertyByName("NumBots")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `minRespawnDelay`*(obj : AGameModePtr): float32 {.exportcpp.} =
let prop = getClassByName("GameMode").getFPropertyByName(
"MinRespawnDelay")
getPropertyValuePtr[float32](prop, obj)[]
proc `minRespawnDelay=`*(obj : AGameModePtr; val : float32) =
var value : float32 = val
let prop = getClassByName("GameMode").getFPropertyByName(
"MinRespawnDelay")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set minRespawnDelay`*(obj : AGameModePtr; val : float32) {.
exportcpp.} =
var value : float32 = val
let prop = getClassByName("GameMode").getFPropertyByName(
"MinRespawnDelay")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `numTravellingPlayers`*(obj : AGameModePtr): int32 {.exportcpp.} =
let prop = getClassByName("GameMode").getFPropertyByName(
"NumTravellingPlayers")
getPropertyValuePtr[int32](prop, obj)[]
proc `numTravellingPlayers=`*(obj : AGameModePtr; val : int32) =
var value : int32 = val
let prop = getClassByName("GameMode").getFPropertyByName(
"NumTravellingPlayers")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `set numTravellingPlayers`*(obj : AGameModePtr;
val : int32) {.exportcpp.} =
var value : int32 = val
let prop = getClassByName("GameMode").getFPropertyByName(
"NumTravellingPlayers")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc startMatch*(self : AGameModePtr): void {.exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "StartMatch"
let fn {.used.} = getClassByName("GameMode").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc say*(self : AGameModePtr; msg : FString): void {.
exportcpp: "$1_".} =
type
Params = object
msg: FString
var param = Params(msg: msg)
let fnName {.used.} = n "Say"
let fn {.used.} = getClassByName("GameMode").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc restartGame*(self : AGameModePtr): void {.exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "RestartGame"
let fn {.used.} = getClassByName("GameMode").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc isMatchInProgress*(self : AGameModePtr): bool {.exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsMatchInProgress"
let fn {.used.} = getClassByName("GameMode").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getMatchState*(self : AGameModePtr): FName {.exportcpp: "$1_".} =
type
Params = object
returnValue: FName
var param = Params()
let fnName {.used.} = n "GetMatchState"
let fn {.used.} = getClassByName("GameMode").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc endMatch*(self : AGameModePtr): void {.exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "EndMatch"
let fn {.used.} = getClassByName("GameMode").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc abortMatch*(self : AGameModePtr): void {.exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "AbortMatch"
let fn {.used.} = getClassByName("GameMode").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc keepAGameMode(fake : AGameMode) {.exportcpp.} =
discard
proc `gameModeClass`*(obj : AGameStateBasePtr): TSubclassOf[
AGameModeBase] {.exportcpp.} =
let prop = getClassByName("GameStateBase").getFPropertyByName(
"GameModeClass")
getPropertyValuePtr[TSubclassOf[AGameModeBase]](prop, obj)[]
proc `gameModeClass=`*(obj : AGameStateBasePtr;
val : TSubclassOf[AGameModeBase]) =
var value : TSubclassOf[AGameModeBase] = val
let prop = getClassByName("GameStateBase").getFPropertyByName(
"GameModeClass")
setPropertyValuePtr[TSubclassOf[AGameModeBase]](prop, obj, value.addr)
proc `set gameModeClass`*(obj : AGameStateBasePtr;
val : TSubclassOf[AGameModeBase]) {.
exportcpp.} =
var value : TSubclassOf[AGameModeBase] = val
let prop = getClassByName("GameStateBase").getFPropertyByName(
"GameModeClass")
setPropertyValuePtr[TSubclassOf[AGameModeBase]](prop, obj, value.addr)
proc `authorityGameMode`*(obj : AGameStateBasePtr): AGameModeBasePtr {.
exportcpp.} =
let prop = getClassByName("GameStateBase").getFPropertyByName(
"AuthorityGameMode")
getPropertyValuePtr[AGameModeBasePtr](prop, obj)[]
proc `authorityGameMode=`*(obj : AGameStateBasePtr;
val : AGameModeBasePtr) =
var value : AGameModeBasePtr = val
let prop = getClassByName("GameStateBase").getFPropertyByName(
"AuthorityGameMode")
setPropertyValuePtr[AGameModeBasePtr](prop, obj, value.addr)
proc `set authorityGameMode`*(obj : AGameStateBasePtr;
val : AGameModeBasePtr) {.exportcpp.} =
var value : AGameModeBasePtr = val
let prop = getClassByName("GameStateBase").getFPropertyByName(
"AuthorityGameMode")
setPropertyValuePtr[AGameModeBasePtr](prop, obj, value.addr)
proc `spectatorClass`*(obj : AGameStateBasePtr): TSubclassOf[
ASpectatorPawn] {.exportcpp.} =
let prop = getClassByName("GameStateBase").getFPropertyByName(
"SpectatorClass")
getPropertyValuePtr[TSubclassOf[ASpectatorPawn]](prop, obj)[]
proc `spectatorClass=`*(obj : AGameStateBasePtr;
val : TSubclassOf[ASpectatorPawn]) =
var value : TSubclassOf[ASpectatorPawn] = val
let prop = getClassByName("GameStateBase").getFPropertyByName(
"SpectatorClass")
setPropertyValuePtr[TSubclassOf[ASpectatorPawn]](prop, obj, value.addr)
proc `set spectatorClass`*(obj : AGameStateBasePtr;
val : TSubclassOf[ASpectatorPawn]) {.
exportcpp.} =
var value : TSubclassOf[ASpectatorPawn] = val
let prop = getClassByName("GameStateBase").getFPropertyByName(
"SpectatorClass")
setPropertyValuePtr[TSubclassOf[ASpectatorPawn]](prop, obj, value.addr)
proc `playerArray`*(obj : AGameStateBasePtr): var TArray[
APlayerStatePtr] {.exportcpp.} =
let prop = getClassByName("GameStateBase").getFPropertyByName(
"PlayerArray")
getPropertyValuePtr[TArray[APlayerStatePtr]](prop, obj)[]
proc `playerArray=`*(obj : AGameStateBasePtr;
val : TArray[APlayerStatePtr]) =
var value : TArray[APlayerStatePtr] = val
let prop = getClassByName("GameStateBase").getFPropertyByName(
"PlayerArray")
setPropertyValuePtr[TArray[APlayerStatePtr]](prop, obj, value.addr)
proc `set playerArray`*(obj : AGameStateBasePtr;
val : TArray[APlayerStatePtr]) {.exportcpp.} =
var value : TArray[APlayerStatePtr] = val
let prop = getClassByName("GameStateBase").getFPropertyByName(
"PlayerArray")
setPropertyValuePtr[TArray[APlayerStatePtr]](prop, obj, value.addr)
proc hasMatchStarted*(self : AGameStateBasePtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "HasMatchStarted"
let fn {.used.} = getClassByName("GameStateBase").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc hasMatchEnded*(self : AGameStateBasePtr): bool {.exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "HasMatchEnded"
let fn {.used.} = getClassByName("GameStateBase").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc hasBegunPlay*(self : AGameStateBasePtr): bool {.exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "HasBegunPlay"
let fn {.used.} = getClassByName("GameStateBase").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getServerWorldTimeSeconds*(self : AGameStateBasePtr): float32 {.
exportcpp: "$1_".} =
type
Params = object
returnValue: float32
var param = Params()
let fnName {.used.} = n "GetServerWorldTimeSeconds"
let fn {.used.} = getClassByName("GameStateBase").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getPlayerStartTime*(self : AGameStateBasePtr;
controller : AControllerPtr): float32 {.
exportcpp: "$1_".} =
type
Params = object
controller: AControllerPtr
returnValue: float32
var param = Params(controller: controller)
let fnName {.used.} = n "GetPlayerStartTime"
let fn {.used.} = getClassByName("GameStateBase").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getPlayerRespawnDelay*(self : AGameStateBasePtr;
controller : AControllerPtr): float32 {.
exportcpp: "$1_".} =
type
Params = object
controller: AControllerPtr
returnValue: float32
var param = Params(controller: controller)
let fnName {.used.} = n "GetPlayerRespawnDelay"
let fn {.used.} = getClassByName("GameStateBase").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc keepAGameStateBase(fake : AGameStateBase) {.exportcpp.} =
discard
proc `playerState`*(obj : AControllerPtr): APlayerStatePtr {.exportcpp.} =
let prop = getClassByName("Controller").getFPropertyByName(
"PlayerState")
getPropertyValuePtr[APlayerStatePtr](prop, obj)[]
proc `playerState=`*(obj : AControllerPtr;
val : APlayerStatePtr) =
var value : APlayerStatePtr = val
let prop = getClassByName("Controller").getFPropertyByName(
"PlayerState")
setPropertyValuePtr[APlayerStatePtr](prop, obj, value.addr)
proc `set playerState`*(obj : AControllerPtr;
val : APlayerStatePtr) {.exportcpp.} =
var value : APlayerStatePtr = val
let prop = getClassByName("Controller").getFPropertyByName(
"PlayerState")
setPropertyValuePtr[APlayerStatePtr](prop, obj, value.addr)
proc unPossess*(self : AControllerPtr): void {.exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "UnPossess"
let fn {.used.} = getClassByName("Controller").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc stopMovement*(self : AControllerPtr): void {.exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "StopMovement"
let fn {.used.} = getClassByName("Controller").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setInitialLocationAndRotation*(self : AControllerPtr;
newLocation : var FVector;
newRotation : var FRotator): void {.
exportcpp: "$1_".} =
type
Params = object
newLocation: FVector
newRotation: FRotator
var param = Params(newLocation: newLocation,
newRotation: newRotation)
let fnName {.used.} = n "SetInitialLocationAndRotation"
let fn {.used.} = getClassByName("Controller").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
newLocation = param.newLocation
newRotation = param.newRotation
proc setIgnoreMoveInput*(self : AControllerPtr;
bNewMoveInput : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bNewMoveInput: bool
var param = Params(bNewMoveInput: bNewMoveInput)
let fnName {.used.} = n "SetIgnoreMoveInput"
let fn {.used.} = getClassByName("Controller").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setIgnoreLookInput*(self : AControllerPtr;
bNewLookInput : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bNewLookInput: bool
var param = Params(bNewLookInput: bNewLookInput)
let fnName {.used.} = n "SetIgnoreLookInput"
let fn {.used.} = getClassByName("Controller").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setControlRotation*(self : AControllerPtr;
newRotation : var FRotator): void {.
exportcpp: "$1_".} =
type
Params = object
newRotation: FRotator
var param = Params(newRotation: newRotation)
let fnName {.used.} = n "SetControlRotation"
let fn {.used.} = getClassByName("Controller").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
newRotation = param.newRotation
proc resetIgnoreMoveInput*(self : AControllerPtr): void {.
exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "ResetIgnoreMoveInput"
let fn {.used.} = getClassByName("Controller").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc resetIgnoreLookInput*(self : AControllerPtr): void {.
exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "ResetIgnoreLookInput"
let fn {.used.} = getClassByName("Controller").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc resetIgnoreInputFlags*(self : AControllerPtr): void {.
exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "ResetIgnoreInputFlags"
let fn {.used.} = getClassByName("Controller").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc possess*(self : AControllerPtr; inPawn : APawnPtr): void {.
exportcpp: "$1_".} =
type
Params = object
inPawn: APawnPtr
var param = Params(inPawn: inPawn)
let fnName {.used.} = n "Possess"
let fn {.used.} = getClassByName("Controller").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc lineOfSightTo*(self : AControllerPtr; other : AActorPtr;
viewPoint : FVector;
bAlternateChecks : bool = false): bool {.
exportcpp: "$1_".} =
type
Params = object
other: AActorPtr
viewPoint: FVector
bAlternateChecks: bool
returnValue: bool
var param = Params(other: other, viewPoint: viewPoint,
bAlternateChecks: bAlternateChecks)
let fnName {.used.} = n "LineOfSightTo"
let fn {.used.} = getClassByName("Controller").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getPawn*(self : AControllerPtr): APawnPtr {.exportcpp: "$1_".} =
type
Params = object
returnValue: APawnPtr
var param = Params()
let fnName {.used.} = n "K2_GetPawn"
let fn {.used.} = getClassByName("Controller").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isPlayerController*(self : AControllerPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsPlayerController"
let fn {.used.} = getClassByName("Controller").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isMoveInputIgnored*(self : AControllerPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsMoveInputIgnored"
let fn {.used.} = getClassByName("Controller").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isLookInputIgnored*(self : AControllerPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsLookInputIgnored"
let fn {.used.} = getClassByName("Controller").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isLocalPlayerController*(self : AControllerPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsLocalPlayerController"
let fn {.used.} = getClassByName("Controller").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isLocalController*(self : AControllerPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsLocalController"
let fn {.used.} = getClassByName("Controller").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getViewTarget*(self : AControllerPtr): AActorPtr {.
exportcpp: "$1_".} =
type
Params = object
returnValue: AActorPtr
var param = Params()
let fnName {.used.} = n "GetViewTarget"
let fn {.used.} = getClassByName("Controller").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getPlayerViewPoint*(self : AControllerPtr;
location : var FVector;
rotation : var FRotator): void {.
exportcpp: "$1_".} =
type
Params = object
location: FVector
rotation: FRotator
var param = Params(location: location, rotation: rotation)
let fnName {.used.} = n "GetPlayerViewPoint"
let fn {.used.} = getClassByName("Controller").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
location = param.location
rotation = param.rotation
proc getDesiredRotation*(self : AControllerPtr): FRotator {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FRotator
var param = Params()
let fnName {.used.} = n "GetDesiredRotation"
let fn {.used.} = getClassByName("Controller").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getControlRotation*(self : AControllerPtr): FRotator {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FRotator
var param = Params()
let fnName {.used.} = n "GetControlRotation"
let fn {.used.} = getClassByName("Controller").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc keepAController(fake : AController) {.exportcpp.} =
discard
converter AControllertoUNavAgentInterface*(self : AControllerPtr): UNavAgentInterfacePtr =
cast[UNavAgentInterfacePtr](self)
proc `lightComponent`*(obj : ASkyLightPtr): USkyLightComponentPtr {.
exportcpp.} =
let prop = getClassByName("SkyLight").getFPropertyByName(
"LightComponent")
getPropertyValuePtr[USkyLightComponentPtr](prop, obj)[]
proc `lightComponent=`*(obj : ASkyLightPtr;
val : USkyLightComponentPtr) =
var value : USkyLightComponentPtr = val
let prop = getClassByName("SkyLight").getFPropertyByName(
"LightComponent")
setPropertyValuePtr[USkyLightComponentPtr](prop, obj, value.addr)
proc `set lightComponent`*(obj : ASkyLightPtr;
val : USkyLightComponentPtr) {.exportcpp.} =
var value : USkyLightComponentPtr = val
let prop = getClassByName("SkyLight").getFPropertyByName(
"LightComponent")
setPropertyValuePtr[USkyLightComponentPtr](prop, obj, value.addr)
proc keepASkyLight(fake : ASkyLight) {.exportcpp.} =
discard
proc `numCinematicMipLevels`*(obj : UStreamableRenderAssetPtr): int32 {.
exportcpp.} =
let prop = getClassByName("StreamableRenderAsset").getFPropertyByName(
"NumCinematicMipLevels")
getPropertyValuePtr[int32](prop, obj)[]
proc `numCinematicMipLevels=`*(obj : UStreamableRenderAssetPtr;
val : int32) =
var value : int32 = val
let prop = getClassByName("StreamableRenderAsset").getFPropertyByName(
"NumCinematicMipLevels")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `set numCinematicMipLevels`*(obj : UStreamableRenderAssetPtr;
val : int32) {.exportcpp.} =
var value : int32 = val
let prop = getClassByName("StreamableRenderAsset").getFPropertyByName(
"NumCinematicMipLevels")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `neverStream`*(obj : UStreamableRenderAssetPtr): uint8 {.
exportcpp.} =
let prop = getClassByName("StreamableRenderAsset").getFPropertyByName(
"NeverStream")
getPropertyValuePtr[uint8](prop, obj)[]
proc `neverStream=`*(obj : UStreamableRenderAssetPtr;
val : uint8) =
var value : uint8 = val
let prop = getClassByName("StreamableRenderAsset").getFPropertyByName(
"NeverStream")
setPropertyValuePtr[uint8](prop, obj, value.addr)
proc `set neverStream`*(obj : UStreamableRenderAssetPtr;
val : uint8) {.exportcpp.} =
var value : uint8 = val
let prop = getClassByName("StreamableRenderAsset").getFPropertyByName(
"NeverStream")
setPropertyValuePtr[uint8](prop, obj, value.addr)
proc `bGlobalForceMipLevelsToBeResident`*(
obj : UStreamableRenderAssetPtr): bool {.exportcpp.} =
let prop = getClassByName("StreamableRenderAsset").getFPropertyByName(
"bGlobalForceMipLevelsToBeResident")
getValueFromBoolProp(prop, obj)
proc `bGlobalForceMipLevelsToBeResident=`*(
obj : UStreamableRenderAssetPtr; val : bool) =
var value : bool = val
let prop = getClassByName("StreamableRenderAsset").getFPropertyByName(
"bGlobalForceMipLevelsToBeResident")
setValueInBoolProp(prop, obj, value)
proc `set bGlobalForceMipLevelsToBeResident`*(
obj : UStreamableRenderAssetPtr; val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("StreamableRenderAsset").getFPropertyByName(
"bGlobalForceMipLevelsToBeResident")
setValueInBoolProp(prop, obj, value)
proc setForceMipLevelsToBeResident*(self : UStreamableRenderAssetPtr;
seconds : float32;
cinematicLODGroupMask : int32 = 0'i32): void {.exportcpp: "$1_".} =
type
Params = object
seconds: float32
cinematicLODGroupMask: int32
var param = Params(seconds: seconds,
cinematicLODGroupMask: cinematicLODGroupMask)
let fnName {.used.} = n "SetForceMipLevelsToBeResident"
let fn {.used.} = getClassByName("StreamableRenderAsset").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc keepUStreamableRenderAsset(fake : UStreamableRenderAsset) {.
exportcpp.} =
discard
proc `adjustBrightness`*(obj : UTexturePtr): float32 {.exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"AdjustBrightness")
getPropertyValuePtr[float32](prop, obj)[]
proc `adjustBrightness=`*(obj : UTexturePtr; val : float32) =
var value : float32 = val
let prop = getClassByName("Texture").getFPropertyByName(
"AdjustBrightness")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set adjustBrightness`*(obj : UTexturePtr; val : float32) {.
exportcpp.} =
var value : float32 = val
let prop = getClassByName("Texture").getFPropertyByName(
"AdjustBrightness")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `adjustBrightnessCurve`*(obj : UTexturePtr): float32 {.exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"AdjustBrightnessCurve")
getPropertyValuePtr[float32](prop, obj)[]
proc `adjustBrightnessCurve=`*(obj : UTexturePtr;
val : float32) =
var value : float32 = val
let prop = getClassByName("Texture").getFPropertyByName(
"AdjustBrightnessCurve")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set adjustBrightnessCurve`*(obj : UTexturePtr;
val : float32) {.exportcpp.} =
var value : float32 = val
let prop = getClassByName("Texture").getFPropertyByName(
"AdjustBrightnessCurve")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `adjustVibrance`*(obj : UTexturePtr): float32 {.exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"AdjustVibrance")
getPropertyValuePtr[float32](prop, obj)[]
proc `adjustVibrance=`*(obj : UTexturePtr; val : float32) =
var value : float32 = val
let prop = getClassByName("Texture").getFPropertyByName(
"AdjustVibrance")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set adjustVibrance`*(obj : UTexturePtr; val : float32) {.
exportcpp.} =
var value : float32 = val
let prop = getClassByName("Texture").getFPropertyByName(
"AdjustVibrance")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `adjustSaturation`*(obj : UTexturePtr): float32 {.exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"AdjustSaturation")
getPropertyValuePtr[float32](prop, obj)[]
proc `adjustSaturation=`*(obj : UTexturePtr; val : float32) =
var value : float32 = val
let prop = getClassByName("Texture").getFPropertyByName(
"AdjustSaturation")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set adjustSaturation`*(obj : UTexturePtr; val : float32) {.
exportcpp.} =
var value : float32 = val
let prop = getClassByName("Texture").getFPropertyByName(
"AdjustSaturation")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `adjustRGBCurve`*(obj : UTexturePtr): float32 {.exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"AdjustRGBCurve")
getPropertyValuePtr[float32](prop, obj)[]
proc `adjustRGBCurve=`*(obj : UTexturePtr; val : float32) =
var value : float32 = val
let prop = getClassByName("Texture").getFPropertyByName(
"AdjustRGBCurve")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set adjustRGBCurve`*(obj : UTexturePtr; val : float32) {.
exportcpp.} =
var value : float32 = val
let prop = getClassByName("Texture").getFPropertyByName(
"AdjustRGBCurve")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `adjustHue`*(obj : UTexturePtr): float32 {.exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName("AdjustHue")
getPropertyValuePtr[float32](prop, obj)[]
proc `adjustHue=`*(obj : UTexturePtr; val : float32) =
var value : float32 = val
let prop = getClassByName("Texture").getFPropertyByName("AdjustHue")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set adjustHue`*(obj : UTexturePtr; val : float32) {.
exportcpp.} =
var value : float32 = val
let prop = getClassByName("Texture").getFPropertyByName("AdjustHue")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `adjustMinAlpha`*(obj : UTexturePtr): float32 {.exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"AdjustMinAlpha")
getPropertyValuePtr[float32](prop, obj)[]
proc `adjustMinAlpha=`*(obj : UTexturePtr; val : float32) =
var value : float32 = val
let prop = getClassByName("Texture").getFPropertyByName(
"AdjustMinAlpha")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set adjustMinAlpha`*(obj : UTexturePtr; val : float32) {.
exportcpp.} =
var value : float32 = val
let prop = getClassByName("Texture").getFPropertyByName(
"AdjustMinAlpha")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `adjustMaxAlpha`*(obj : UTexturePtr): float32 {.exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"AdjustMaxAlpha")
getPropertyValuePtr[float32](prop, obj)[]
proc `adjustMaxAlpha=`*(obj : UTexturePtr; val : float32) =
var value : float32 = val
let prop = getClassByName("Texture").getFPropertyByName(
"AdjustMaxAlpha")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set adjustMaxAlpha`*(obj : UTexturePtr; val : float32) {.
exportcpp.} =
var value : float32 = val
let prop = getClassByName("Texture").getFPropertyByName(
"AdjustMaxAlpha")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `compressionNoAlpha`*(obj : UTexturePtr): uint8 {.exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"CompressionNoAlpha")
getPropertyValuePtr[uint8](prop, obj)[]
proc `compressionNoAlpha=`*(obj : UTexturePtr; val : uint8) =
var value : uint8 = val
let prop = getClassByName("Texture").getFPropertyByName(
"CompressionNoAlpha")
setPropertyValuePtr[uint8](prop, obj, value.addr)
proc `set compressionNoAlpha`*(obj : UTexturePtr; val : uint8) {.
exportcpp.} =
var value : uint8 = val
let prop = getClassByName("Texture").getFPropertyByName(
"CompressionNoAlpha")
setPropertyValuePtr[uint8](prop, obj, value.addr)
proc `compressFinal`*(obj : UTexturePtr): uint8 {.exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"CompressFinal")
getPropertyValuePtr[uint8](prop, obj)[]
proc `compressFinal=`*(obj : UTexturePtr; val : uint8) =
var value : uint8 = val
let prop = getClassByName("Texture").getFPropertyByName(
"CompressFinal")
setPropertyValuePtr[uint8](prop, obj, value.addr)
proc `set compressFinal`*(obj : UTexturePtr; val : uint8) {.
exportcpp.} =
var value : uint8 = val
let prop = getClassByName("Texture").getFPropertyByName(
"CompressFinal")
setPropertyValuePtr[uint8](prop, obj, value.addr)
proc `deferCompression`*(obj : UTexturePtr): uint8 {.exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"DeferCompression")
getPropertyValuePtr[uint8](prop, obj)[]
proc `deferCompression=`*(obj : UTexturePtr; val : uint8) =
var value : uint8 = val
let prop = getClassByName("Texture").getFPropertyByName(
"DeferCompression")
setPropertyValuePtr[uint8](prop, obj, value.addr)
proc `set deferCompression`*(obj : UTexturePtr; val : uint8) {.
exportcpp.} =
var value : uint8 = val
let prop = getClassByName("Texture").getFPropertyByName(
"DeferCompression")
setPropertyValuePtr[uint8](prop, obj, value.addr)
proc `lossyCompressionAmount`*(obj : UTexturePtr): ETextureLossyCompressionAmount {.
exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"LossyCompressionAmount")
getPropertyValuePtr[ETextureLossyCompressionAmount](prop, obj)[]
proc `lossyCompressionAmount=`*(obj : UTexturePtr;
val : ETextureLossyCompressionAmount) =
var value : ETextureLossyCompressionAmount = val
let prop = getClassByName("Texture").getFPropertyByName(
"LossyCompressionAmount")
setPropertyValuePtr[ETextureLossyCompressionAmount](prop, obj, value.addr)
proc `set lossyCompressionAmount`*(obj : UTexturePtr; val : ETextureLossyCompressionAmount) {.
exportcpp.} =
var value : ETextureLossyCompressionAmount = val
let prop = getClassByName("Texture").getFPropertyByName(
"LossyCompressionAmount")
setPropertyValuePtr[ETextureLossyCompressionAmount](prop, obj, value.addr)
proc `oodleTextureSdkVersion`*(obj : UTexturePtr): var FName {.
exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"OodleTextureSdkVersion")
getPropertyValuePtr[FName](prop, obj)[]
proc `oodleTextureSdkVersion=`*(obj : UTexturePtr;
val : FName) =
var value : FName = val
let prop = getClassByName("Texture").getFPropertyByName(
"OodleTextureSdkVersion")
setPropertyValuePtr[FName](prop, obj, value.addr)
proc `set oodleTextureSdkVersion`*(obj : UTexturePtr;
val : FName) {.exportcpp.} =
var value : FName = val
let prop = getClassByName("Texture").getFPropertyByName(
"OodleTextureSdkVersion")
setPropertyValuePtr[FName](prop, obj, value.addr)
proc `maxTextureSize`*(obj : UTexturePtr): int32 {.exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"MaxTextureSize")
getPropertyValuePtr[int32](prop, obj)[]
proc `maxTextureSize=`*(obj : UTexturePtr; val : int32) =
var value : int32 = val
let prop = getClassByName("Texture").getFPropertyByName(
"MaxTextureSize")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `set maxTextureSize`*(obj : UTexturePtr; val : int32) {.
exportcpp.} =
var value : int32 = val
let prop = getClassByName("Texture").getFPropertyByName(
"MaxTextureSize")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `compressionQuality`*(obj : UTexturePtr): ETextureCompressionQuality {.
exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"CompressionQuality")
getPropertyValuePtr[ETextureCompressionQuality](prop, obj)[]
proc `compressionQuality=`*(obj : UTexturePtr;
val : ETextureCompressionQuality) =
var value : ETextureCompressionQuality = val
let prop = getClassByName("Texture").getFPropertyByName(
"CompressionQuality")
setPropertyValuePtr[ETextureCompressionQuality](prop, obj, value.addr)
proc `set compressionQuality`*(obj : UTexturePtr;
val : ETextureCompressionQuality) {.
exportcpp.} =
var value : ETextureCompressionQuality = val
let prop = getClassByName("Texture").getFPropertyByName(
"CompressionQuality")
setPropertyValuePtr[ETextureCompressionQuality](prop, obj, value.addr)
proc `bDoScaleMipsForAlphaCoverage`*(obj : UTexturePtr): bool {.
exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"bDoScaleMipsForAlphaCoverage")
getValueFromBoolProp(prop, obj)
proc `bDoScaleMipsForAlphaCoverage=`*(obj : UTexturePtr;
val : bool) =
var value : bool = val
let prop = getClassByName("Texture").getFPropertyByName(
"bDoScaleMipsForAlphaCoverage")
setValueInBoolProp(prop, obj, value)
proc `set bDoScaleMipsForAlphaCoverage`*(obj : UTexturePtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("Texture").getFPropertyByName(
"bDoScaleMipsForAlphaCoverage")
setValueInBoolProp(prop, obj, value)
proc `alphaCoverageThresholds`*(obj : UTexturePtr): var FVector4 {.
exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"AlphaCoverageThresholds")
getPropertyValuePtr[FVector4](prop, obj)[]
proc `alphaCoverageThresholds=`*(obj : UTexturePtr;
val : FVector4) =
var value : FVector4 = val
let prop = getClassByName("Texture").getFPropertyByName(
"AlphaCoverageThresholds")
setPropertyValuePtr[FVector4](prop, obj, value.addr)
proc `set alphaCoverageThresholds`*(obj : UTexturePtr;
val : FVector4) {.exportcpp.} =
var value : FVector4 = val
let prop = getClassByName("Texture").getFPropertyByName(
"AlphaCoverageThresholds")
setPropertyValuePtr[FVector4](prop, obj, value.addr)
proc `bUseNewMipFilter`*(obj : UTexturePtr): bool {.exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"bUseNewMipFilter")
getValueFromBoolProp(prop, obj)
proc `bUseNewMipFilter=`*(obj : UTexturePtr; val : bool) =
var value : bool = val
let prop = getClassByName("Texture").getFPropertyByName(
"bUseNewMipFilter")
setValueInBoolProp(prop, obj, value)
proc `set bUseNewMipFilter`*(obj : UTexturePtr; val : bool) {.
exportcpp.} =
var value : bool = val
let prop = getClassByName("Texture").getFPropertyByName(
"bUseNewMipFilter")
setValueInBoolProp(prop, obj, value)
proc `bPreserveBorder`*(obj : UTexturePtr): bool {.exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"bPreserveBorder")
getValueFromBoolProp(prop, obj)
proc `bPreserveBorder=`*(obj : UTexturePtr; val : bool) =
var value : bool = val
let prop = getClassByName("Texture").getFPropertyByName(
"bPreserveBorder")
setValueInBoolProp(prop, obj, value)
proc `set bPreserveBorder`*(obj : UTexturePtr; val : bool) {.
exportcpp.} =
var value : bool = val
let prop = getClassByName("Texture").getFPropertyByName(
"bPreserveBorder")
setValueInBoolProp(prop, obj, value)
proc `bFlipGreenChannel`*(obj : UTexturePtr): bool {.exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"bFlipGreenChannel")
getValueFromBoolProp(prop, obj)
proc `bFlipGreenChannel=`*(obj : UTexturePtr; val : bool) =
var value : bool = val
let prop = getClassByName("Texture").getFPropertyByName(
"bFlipGreenChannel")
setValueInBoolProp(prop, obj, value)
proc `set bFlipGreenChannel`*(obj : UTexturePtr; val : bool) {.
exportcpp.} =
var value : bool = val
let prop = getClassByName("Texture").getFPropertyByName(
"bFlipGreenChannel")
setValueInBoolProp(prop, obj, value)
proc `powerOfTwoMode`*(obj : UTexturePtr): ETexturePowerOfTwoSetting {.
exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"PowerOfTwoMode")
getPropertyValuePtr[ETexturePowerOfTwoSetting](prop, obj)[]
proc `powerOfTwoMode=`*(obj : UTexturePtr;
val : ETexturePowerOfTwoSetting) =
var value : ETexturePowerOfTwoSetting = val
let prop = getClassByName("Texture").getFPropertyByName(
"PowerOfTwoMode")
setPropertyValuePtr[ETexturePowerOfTwoSetting](prop, obj, value.addr)
proc `set powerOfTwoMode`*(obj : UTexturePtr;
val : ETexturePowerOfTwoSetting) {.
exportcpp.} =
var value : ETexturePowerOfTwoSetting = val
let prop = getClassByName("Texture").getFPropertyByName(
"PowerOfTwoMode")
setPropertyValuePtr[ETexturePowerOfTwoSetting](prop, obj, value.addr)
proc `paddingColor`*(obj : UTexturePtr): var FColor {.exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"PaddingColor")
getPropertyValuePtr[FColor](prop, obj)[]
proc `paddingColor=`*(obj : UTexturePtr; val : FColor) =
var value : FColor = val
let prop = getClassByName("Texture").getFPropertyByName(
"PaddingColor")
setPropertyValuePtr[FColor](prop, obj, value.addr)
proc `set paddingColor`*(obj : UTexturePtr; val : FColor) {.
exportcpp.} =
var value : FColor = val
let prop = getClassByName("Texture").getFPropertyByName(
"PaddingColor")
setPropertyValuePtr[FColor](prop, obj, value.addr)
proc `bChromaKeyTexture`*(obj : UTexturePtr): bool {.exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"bChromaKeyTexture")
getValueFromBoolProp(prop, obj)
proc `bChromaKeyTexture=`*(obj : UTexturePtr; val : bool) =
var value : bool = val
let prop = getClassByName("Texture").getFPropertyByName(
"bChromaKeyTexture")
setValueInBoolProp(prop, obj, value)
proc `set bChromaKeyTexture`*(obj : UTexturePtr; val : bool) {.
exportcpp.} =
var value : bool = val
let prop = getClassByName("Texture").getFPropertyByName(
"bChromaKeyTexture")
setValueInBoolProp(prop, obj, value)
proc `chromaKeyThreshold`*(obj : UTexturePtr): float32 {.exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"ChromaKeyThreshold")
getPropertyValuePtr[float32](prop, obj)[]
proc `chromaKeyThreshold=`*(obj : UTexturePtr; val : float32) =
var value : float32 = val
let prop = getClassByName("Texture").getFPropertyByName(
"ChromaKeyThreshold")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set chromaKeyThreshold`*(obj : UTexturePtr;
val : float32) {.exportcpp.} =
var value : float32 = val
let prop = getClassByName("Texture").getFPropertyByName(
"ChromaKeyThreshold")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `chromaKeyColor`*(obj : UTexturePtr): var FColor {.exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"ChromaKeyColor")
getPropertyValuePtr[FColor](prop, obj)[]
proc `chromaKeyColor=`*(obj : UTexturePtr; val : FColor) =
var value : FColor = val
let prop = getClassByName("Texture").getFPropertyByName(
"ChromaKeyColor")
setPropertyValuePtr[FColor](prop, obj, value.addr)
proc `set chromaKeyColor`*(obj : UTexturePtr; val : FColor) {.
exportcpp.} =
var value : FColor = val
let prop = getClassByName("Texture").getFPropertyByName(
"ChromaKeyColor")
setPropertyValuePtr[FColor](prop, obj, value.addr)
proc `mipGenSettings`*(obj : UTexturePtr): TextureMipGenSettings {.
exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"MipGenSettings")
getPropertyValuePtr[TextureMipGenSettings](prop, obj)[]
proc `mipGenSettings=`*(obj : UTexturePtr;
val : TextureMipGenSettings) =
var value : TextureMipGenSettings = val
let prop = getClassByName("Texture").getFPropertyByName(
"MipGenSettings")
setPropertyValuePtr[TextureMipGenSettings](prop, obj, value.addr)
proc `set mipGenSettings`*(obj : UTexturePtr;
val : TextureMipGenSettings) {.exportcpp.} =
var value : TextureMipGenSettings = val
let prop = getClassByName("Texture").getFPropertyByName(
"MipGenSettings")
setPropertyValuePtr[TextureMipGenSettings](prop, obj, value.addr)
proc `compositeTexture`*(obj : UTexturePtr): UTexturePtr {.exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"CompositeTexture")
getPropertyValuePtr[UTexturePtr](prop, obj)[]
proc `compositeTexture=`*(obj : UTexturePtr;
val : UTexturePtr) =
var value : UTexturePtr = val
let prop = getClassByName("Texture").getFPropertyByName(
"CompositeTexture")
setPropertyValuePtr[UTexturePtr](prop, obj, value.addr)
proc `set compositeTexture`*(obj : UTexturePtr;
val : UTexturePtr) {.exportcpp.} =
var value : UTexturePtr = val
let prop = getClassByName("Texture").getFPropertyByName(
"CompositeTexture")
setPropertyValuePtr[UTexturePtr](prop, obj, value.addr)
proc `compositeTextureMode`*(obj : UTexturePtr): ECompositeTextureMode {.
exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"CompositeTextureMode")
getPropertyValuePtr[ECompositeTextureMode](prop, obj)[]
proc `compositeTextureMode=`*(obj : UTexturePtr;
val : ECompositeTextureMode) =
var value : ECompositeTextureMode = val
let prop = getClassByName("Texture").getFPropertyByName(
"CompositeTextureMode")
setPropertyValuePtr[ECompositeTextureMode](prop, obj, value.addr)
proc `set compositeTextureMode`*(obj : UTexturePtr;
val : ECompositeTextureMode) {.
exportcpp.} =
var value : ECompositeTextureMode = val
let prop = getClassByName("Texture").getFPropertyByName(
"CompositeTextureMode")
setPropertyValuePtr[ECompositeTextureMode](prop, obj, value.addr)
proc `compositePower`*(obj : UTexturePtr): float32 {.exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"CompositePower")
getPropertyValuePtr[float32](prop, obj)[]
proc `compositePower=`*(obj : UTexturePtr; val : float32) =
var value : float32 = val
let prop = getClassByName("Texture").getFPropertyByName(
"CompositePower")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set compositePower`*(obj : UTexturePtr; val : float32) {.
exportcpp.} =
var value : float32 = val
let prop = getClassByName("Texture").getFPropertyByName(
"CompositePower")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `lODBias`*(obj : UTexturePtr): int32 {.exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName("LODBias")
getPropertyValuePtr[int32](prop, obj)[]
proc `lODBias=`*(obj : UTexturePtr; val : int32) =
var value : int32 = val
let prop = getClassByName("Texture").getFPropertyByName("LODBias")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `set lODBias`*(obj : UTexturePtr; val : int32) {.
exportcpp.} =
var value : int32 = val
let prop = getClassByName("Texture").getFPropertyByName("LODBias")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `compressionSettings`*(obj : UTexturePtr): TextureCompressionSettings {.
exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"CompressionSettings")
getPropertyValuePtr[TextureCompressionSettings](prop, obj)[]
proc `compressionSettings=`*(obj : UTexturePtr;
val : TextureCompressionSettings) =
var value : TextureCompressionSettings = val
let prop = getClassByName("Texture").getFPropertyByName(
"CompressionSettings")
setPropertyValuePtr[TextureCompressionSettings](prop, obj, value.addr)
proc `set compressionSettings`*(obj : UTexturePtr;
val : TextureCompressionSettings) {.
exportcpp.} =
var value : TextureCompressionSettings = val
let prop = getClassByName("Texture").getFPropertyByName(
"CompressionSettings")
setPropertyValuePtr[TextureCompressionSettings](prop, obj, value.addr)
proc `filter`*(obj : UTexturePtr): TextureFilter {.exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName("Filter")
getPropertyValuePtr[TextureFilter](prop, obj)[]
proc `filter=`*(obj : UTexturePtr; val : TextureFilter) =
var value : TextureFilter = val
let prop = getClassByName("Texture").getFPropertyByName("Filter")
setPropertyValuePtr[TextureFilter](prop, obj, value.addr)
proc `set filter`*(obj : UTexturePtr; val : TextureFilter) {.
exportcpp.} =
var value : TextureFilter = val
let prop = getClassByName("Texture").getFPropertyByName("Filter")
setPropertyValuePtr[TextureFilter](prop, obj, value.addr)
proc `mipLoadOptions`*(obj : UTexturePtr): ETextureMipLoadOptions {.
exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"MipLoadOptions")
getPropertyValuePtr[ETextureMipLoadOptions](prop, obj)[]
proc `mipLoadOptions=`*(obj : UTexturePtr;
val : ETextureMipLoadOptions) =
var value : ETextureMipLoadOptions = val
let prop = getClassByName("Texture").getFPropertyByName(
"MipLoadOptions")
setPropertyValuePtr[ETextureMipLoadOptions](prop, obj, value.addr)
proc `set mipLoadOptions`*(obj : UTexturePtr;
val : ETextureMipLoadOptions) {.exportcpp.} =
var value : ETextureMipLoadOptions = val
let prop = getClassByName("Texture").getFPropertyByName(
"MipLoadOptions")
setPropertyValuePtr[ETextureMipLoadOptions](prop, obj, value.addr)
proc `lODGroup`*(obj : UTexturePtr): TextureGroup {.exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName("LODGroup")
getPropertyValuePtr[TextureGroup](prop, obj)[]
proc `lODGroup=`*(obj : UTexturePtr; val : TextureGroup) =
var value : TextureGroup = val
let prop = getClassByName("Texture").getFPropertyByName("LODGroup")
setPropertyValuePtr[TextureGroup](prop, obj, value.addr)
proc `set lODGroup`*(obj : UTexturePtr; val : TextureGroup) {.
exportcpp.} =
var value : TextureGroup = val
let prop = getClassByName("Texture").getFPropertyByName("LODGroup")
setPropertyValuePtr[TextureGroup](prop, obj, value.addr)
proc `sRGB`*(obj : UTexturePtr): uint8 {.exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName("SRGB")
getPropertyValuePtr[uint8](prop, obj)[]
proc `sRGB=`*(obj : UTexturePtr; val : uint8) =
var value : uint8 = val
let prop = getClassByName("Texture").getFPropertyByName("SRGB")
setPropertyValuePtr[uint8](prop, obj, value.addr)
proc `set sRGB`*(obj : UTexturePtr; val : uint8) {.exportcpp.} =
var value : uint8 = val
let prop = getClassByName("Texture").getFPropertyByName("SRGB")
setPropertyValuePtr[uint8](prop, obj, value.addr)
proc `bUseLegacyGamma`*(obj : UTexturePtr): bool {.exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"bUseLegacyGamma")
getValueFromBoolProp(prop, obj)
proc `bUseLegacyGamma=`*(obj : UTexturePtr; val : bool) =
var value : bool = val
let prop = getClassByName("Texture").getFPropertyByName(
"bUseLegacyGamma")
setValueInBoolProp(prop, obj, value)
proc `set bUseLegacyGamma`*(obj : UTexturePtr; val : bool) {.
exportcpp.} =
var value : bool = val
let prop = getClassByName("Texture").getFPropertyByName(
"bUseLegacyGamma")
setValueInBoolProp(prop, obj, value)
proc `sourceColorSettings`*(obj : UTexturePtr): var FTextureSourceColorSettings {.
exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"SourceColorSettings")
getPropertyValuePtr[FTextureSourceColorSettings](prop, obj)[]
proc `sourceColorSettings=`*(obj : UTexturePtr;
val : FTextureSourceColorSettings) =
var value : FTextureSourceColorSettings = val
let prop = getClassByName("Texture").getFPropertyByName(
"SourceColorSettings")
setPropertyValuePtr[FTextureSourceColorSettings](prop, obj, value.addr)
proc `set sourceColorSettings`*(obj : UTexturePtr;
val : FTextureSourceColorSettings) {.
exportcpp.} =
var value : FTextureSourceColorSettings = val
let prop = getClassByName("Texture").getFPropertyByName(
"SourceColorSettings")
setPropertyValuePtr[FTextureSourceColorSettings](prop, obj, value.addr)
proc `virtualTextureStreaming`*(obj : UTexturePtr): uint8 {.exportcpp.} =
let prop = getClassByName("Texture").getFPropertyByName(
"VirtualTextureStreaming")
getPropertyValuePtr[uint8](prop, obj)[]
proc `virtualTextureStreaming=`*(obj : UTexturePtr;
val : uint8) =
var value : uint8 = val
let prop = getClassByName("Texture").getFPropertyByName(
"VirtualTextureStreaming")
setPropertyValuePtr[uint8](prop, obj, value.addr)
proc `set virtualTextureStreaming`*(obj : UTexturePtr;
val : uint8) {.exportcpp.} =
var value : uint8 = val
let prop = getClassByName("Texture").getFPropertyByName(
"VirtualTextureStreaming")
setPropertyValuePtr[uint8](prop, obj, value.addr)
proc blueprint_GetMemorySize*(self : UTexturePtr): int64 {.
exportcpp: "$1_".} =
type
Params = object
returnValue: int64
var param = Params()
let fnName {.used.} = n "Blueprint_GetMemorySize"
let fn {.used.} = getClassByName("Texture").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc keepUTexture(fake : UTexture) {.exportcpp.} =
discard
converter UTexturetoUInterface_AssetUserData*(self : UTexturePtr): UInterface_AssetUserDataPtr =
cast[UInterface_AssetUserDataPtr](self)
converter UTexturetoUInterface_AsyncCompilation*(self : UTexturePtr): UInterface_AsyncCompilationPtr =
cast[UInterface_AsyncCompilationPtr](self)
proc keepUTextureCube(fake : UTextureCube) {.exportcpp.} =
discard
proc `forcedLodModel`*(obj : UStaticMeshComponentPtr): int32 {.
exportcpp.} =
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"ForcedLodModel")
getPropertyValuePtr[int32](prop, obj)[]
proc `forcedLodModel=`*(obj : UStaticMeshComponentPtr;
val : int32) =
var value : int32 = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"ForcedLodModel")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `set forcedLodModel`*(obj : UStaticMeshComponentPtr;
val : int32) {.exportcpp.} =
var value : int32 = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"ForcedLodModel")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `minLOD`*(obj : UStaticMeshComponentPtr): int32 {.exportcpp.} =
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"MinLOD")
getPropertyValuePtr[int32](prop, obj)[]
proc `minLOD=`*(obj : UStaticMeshComponentPtr; val : int32) =
var value : int32 = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"MinLOD")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `set minLOD`*(obj : UStaticMeshComponentPtr; val : int32) {.
exportcpp.} =
var value : int32 = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"MinLOD")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `staticMesh`*(obj : UStaticMeshComponentPtr): UStaticMeshPtr {.
exportcpp.} =
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"StaticMesh")
getPropertyValuePtr[UStaticMeshPtr](prop, obj)[]
proc `staticMesh=`*(obj : UStaticMeshComponentPtr;
val : UStaticMeshPtr) =
var value : UStaticMeshPtr = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"StaticMesh")
setPropertyValuePtr[UStaticMeshPtr](prop, obj, value.addr)
proc `set staticMesh`*(obj : UStaticMeshComponentPtr;
val : UStaticMeshPtr) {.exportcpp.} =
var value : UStaticMeshPtr = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"StaticMesh")
setPropertyValuePtr[UStaticMeshPtr](prop, obj, value.addr)
proc `wireframeColorOverride`*(obj : UStaticMeshComponentPtr): var FColor {.
exportcpp.} =
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"WireframeColorOverride")
getPropertyValuePtr[FColor](prop, obj)[]
proc `wireframeColorOverride=`*(obj : UStaticMeshComponentPtr;
val : FColor) =
var value : FColor = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"WireframeColorOverride")
setPropertyValuePtr[FColor](prop, obj, value.addr)
proc `set wireframeColorOverride`*(obj : UStaticMeshComponentPtr;
val : FColor) {.exportcpp.} =
var value : FColor = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"WireframeColorOverride")
setPropertyValuePtr[FColor](prop, obj, value.addr)
proc `bDisallowNanite`*(obj : UStaticMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bDisallowNanite")
getValueFromBoolProp(prop, obj)
proc `bDisallowNanite=`*(obj : UStaticMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bDisallowNanite")
setValueInBoolProp(prop, obj, value)
proc `set bDisallowNanite`*(obj : UStaticMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bDisallowNanite")
setValueInBoolProp(prop, obj, value)
proc `bEvaluateWorldPositionOffset`*(obj : UStaticMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bEvaluateWorldPositionOffset")
getValueFromBoolProp(prop, obj)
proc `bEvaluateWorldPositionOffset=`*(obj : UStaticMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bEvaluateWorldPositionOffset")
setValueInBoolProp(prop, obj, value)
proc `set bEvaluateWorldPositionOffset`*(obj : UStaticMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bEvaluateWorldPositionOffset")
setValueInBoolProp(prop, obj, value)
proc `bEvaluateWorldPositionOffsetInRayTracing`*(
obj : UStaticMeshComponentPtr): bool {.exportcpp.} =
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bEvaluateWorldPositionOffsetInRayTracing")
getValueFromBoolProp(prop, obj)
proc `bEvaluateWorldPositionOffsetInRayTracing=`*(
obj : UStaticMeshComponentPtr; val : bool) =
var value : bool = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bEvaluateWorldPositionOffsetInRayTracing")
setValueInBoolProp(prop, obj, value)
proc `set bEvaluateWorldPositionOffsetInRayTracing`*(
obj : UStaticMeshComponentPtr; val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bEvaluateWorldPositionOffsetInRayTracing")
setValueInBoolProp(prop, obj, value)
proc `worldPositionOffsetDisableDistance`*(
obj : UStaticMeshComponentPtr): int32 {.exportcpp.} =
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"WorldPositionOffsetDisableDistance")
getPropertyValuePtr[int32](prop, obj)[]
proc `worldPositionOffsetDisableDistance=`*(
obj : UStaticMeshComponentPtr; val : int32) =
var value : int32 = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"WorldPositionOffsetDisableDistance")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `set worldPositionOffsetDisableDistance`*(
obj : UStaticMeshComponentPtr; val : int32) {.exportcpp.} =
var value : int32 = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"WorldPositionOffsetDisableDistance")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `bOverrideWireframeColor`*(obj : UStaticMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bOverrideWireframeColor")
getValueFromBoolProp(prop, obj)
proc `bOverrideWireframeColor=`*(obj : UStaticMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bOverrideWireframeColor")
setValueInBoolProp(prop, obj, value)
proc `set bOverrideWireframeColor`*(obj : UStaticMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bOverrideWireframeColor")
setValueInBoolProp(prop, obj, value)
proc `bOverrideMinLOD`*(obj : UStaticMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bOverrideMinLOD")
getValueFromBoolProp(prop, obj)
proc `bOverrideMinLOD=`*(obj : UStaticMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bOverrideMinLOD")
setValueInBoolProp(prop, obj, value)
proc `set bOverrideMinLOD`*(obj : UStaticMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bOverrideMinLOD")
setValueInBoolProp(prop, obj, value)
proc `bDisallowMeshPaintPerInstance`*(obj : UStaticMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bDisallowMeshPaintPerInstance")
getValueFromBoolProp(prop, obj)
proc `bDisallowMeshPaintPerInstance=`*(obj : UStaticMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bDisallowMeshPaintPerInstance")
setValueInBoolProp(prop, obj, value)
proc `set bDisallowMeshPaintPerInstance`*(
obj : UStaticMeshComponentPtr; val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bDisallowMeshPaintPerInstance")
setValueInBoolProp(prop, obj, value)
proc `bIgnoreInstanceForTextureStreaming`*(
obj : UStaticMeshComponentPtr): bool {.exportcpp.} =
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bIgnoreInstanceForTextureStreaming")
getValueFromBoolProp(prop, obj)
proc `bIgnoreInstanceForTextureStreaming=`*(
obj : UStaticMeshComponentPtr; val : bool) =
var value : bool = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bIgnoreInstanceForTextureStreaming")
setValueInBoolProp(prop, obj, value)
proc `set bIgnoreInstanceForTextureStreaming`*(
obj : UStaticMeshComponentPtr; val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bIgnoreInstanceForTextureStreaming")
setValueInBoolProp(prop, obj, value)
proc `bOverrideLightMapRes`*(obj : UStaticMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bOverrideLightMapRes")
getValueFromBoolProp(prop, obj)
proc `bOverrideLightMapRes=`*(obj : UStaticMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bOverrideLightMapRes")
setValueInBoolProp(prop, obj, value)
proc `set bOverrideLightMapRes`*(obj : UStaticMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bOverrideLightMapRes")
setValueInBoolProp(prop, obj, value)
proc `bCastDistanceFieldIndirectShadow`*(obj : UStaticMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bCastDistanceFieldIndirectShadow")
getValueFromBoolProp(prop, obj)
proc `bCastDistanceFieldIndirectShadow=`*(
obj : UStaticMeshComponentPtr; val : bool) =
var value : bool = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bCastDistanceFieldIndirectShadow")
setValueInBoolProp(prop, obj, value)
proc `set bCastDistanceFieldIndirectShadow`*(
obj : UStaticMeshComponentPtr; val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bCastDistanceFieldIndirectShadow")
setValueInBoolProp(prop, obj, value)
proc `bOverrideDistanceFieldSelfShadowBias`*(
obj : UStaticMeshComponentPtr): bool {.exportcpp.} =
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bOverrideDistanceFieldSelfShadowBias")
getValueFromBoolProp(prop, obj)
proc `bOverrideDistanceFieldSelfShadowBias=`*(
obj : UStaticMeshComponentPtr; val : bool) =
var value : bool = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bOverrideDistanceFieldSelfShadowBias")
setValueInBoolProp(prop, obj, value)
proc `set bOverrideDistanceFieldSelfShadowBias`*(
obj : UStaticMeshComponentPtr; val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bOverrideDistanceFieldSelfShadowBias")
setValueInBoolProp(prop, obj, value)
proc `bSortTriangles`*(obj : UStaticMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bSortTriangles")
getValueFromBoolProp(prop, obj)
proc `bSortTriangles=`*(obj : UStaticMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bSortTriangles")
setValueInBoolProp(prop, obj, value)
proc `set bSortTriangles`*(obj : UStaticMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bSortTriangles")
setValueInBoolProp(prop, obj, value)
proc `bReverseCulling`*(obj : UStaticMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bReverseCulling")
getValueFromBoolProp(prop, obj)
proc `bReverseCulling=`*(obj : UStaticMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bReverseCulling")
setValueInBoolProp(prop, obj, value)
proc `set bReverseCulling`*(obj : UStaticMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"bReverseCulling")
setValueInBoolProp(prop, obj, value)
proc `overriddenLightMapRes`*(obj : UStaticMeshComponentPtr): int32 {.
exportcpp.} =
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"OverriddenLightMapRes")
getPropertyValuePtr[int32](prop, obj)[]
proc `overriddenLightMapRes=`*(obj : UStaticMeshComponentPtr;
val : int32) =
var value : int32 = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"OverriddenLightMapRes")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `set overriddenLightMapRes`*(obj : UStaticMeshComponentPtr;
val : int32) {.exportcpp.} =
var value : int32 = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"OverriddenLightMapRes")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `distanceFieldIndirectShadowMinVisibility`*(
obj : UStaticMeshComponentPtr): float32 {.exportcpp.} =
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"DistanceFieldIndirectShadowMinVisibility")
getPropertyValuePtr[float32](prop, obj)[]
proc `distanceFieldIndirectShadowMinVisibility=`*(
obj : UStaticMeshComponentPtr; val : float32) =
var value : float32 = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"DistanceFieldIndirectShadowMinVisibility")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set distanceFieldIndirectShadowMinVisibility`*(
obj : UStaticMeshComponentPtr; val : float32) {.
exportcpp.} =
var value : float32 = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"DistanceFieldIndirectShadowMinVisibility")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `distanceFieldSelfShadowBias`*(obj : UStaticMeshComponentPtr): float32 {.
exportcpp.} =
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"DistanceFieldSelfShadowBias")
getPropertyValuePtr[float32](prop, obj)[]
proc `distanceFieldSelfShadowBias=`*(obj : UStaticMeshComponentPtr;
val : float32) =
var value : float32 = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"DistanceFieldSelfShadowBias")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set distanceFieldSelfShadowBias`*(obj : UStaticMeshComponentPtr;
val : float32) {.exportcpp.} =
var value : float32 = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"DistanceFieldSelfShadowBias")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `streamingDistanceMultiplier`*(obj : UStaticMeshComponentPtr): float32 {.
exportcpp.} =
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"StreamingDistanceMultiplier")
getPropertyValuePtr[float32](prop, obj)[]
proc `streamingDistanceMultiplier=`*(obj : UStaticMeshComponentPtr;
val : float32) =
var value : float32 = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"StreamingDistanceMultiplier")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set streamingDistanceMultiplier`*(obj : UStaticMeshComponentPtr;
val : float32) {.exportcpp.} =
var value : float32 = val
let prop = getClassByName("StaticMeshComponent").getFPropertyByName(
"StreamingDistanceMultiplier")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc setStaticMesh*(self : UStaticMeshComponentPtr;
newMesh : UStaticMeshPtr): bool {.exportcpp: "$1_".} =
type
Params = object
newMesh: UStaticMeshPtr
returnValue: bool
var param = Params(newMesh: newMesh)
let fnName {.used.} = n "SetStaticMesh"
let fn {.used.} = getClassByName("StaticMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc setReverseCulling*(self : UStaticMeshComponentPtr;
reverseCulling : bool): void {.
exportcpp: "$1_".} =
type
Params = object
reverseCulling: bool
var param = Params(reverseCulling: reverseCulling)
let fnName {.used.} = n "SetReverseCulling"
let fn {.used.} = getClassByName("StaticMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setForcedLodModel*(self : UStaticMeshComponentPtr;
newForcedLodModel : int32): void {.
exportcpp: "$1_".} =
type
Params = object
newForcedLodModel: int32
var param = Params(newForcedLodModel: newForcedLodModel)
let fnName {.used.} = n "SetForcedLodModel"
let fn {.used.} = getClassByName("StaticMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setEvaluateWorldPositionOffsetInRayTracing*(
self : UStaticMeshComponentPtr; newValue : bool): void {.
exportcpp: "$1_".} =
type
Params = object
newValue: bool
var param = Params(newValue: newValue)
let fnName {.used.} = n "SetEvaluateWorldPositionOffsetInRayTracing"
let fn {.used.} = getClassByName("StaticMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setEvaluateWorldPositionOffset*(self : UStaticMeshComponentPtr;
newValue : bool): void {.
exportcpp: "$1_".} =
type
Params = object
newValue: bool
var param = Params(newValue: newValue)
let fnName {.used.} = n "SetEvaluateWorldPositionOffset"
let fn {.used.} = getClassByName("StaticMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setDistanceFieldSelfShadowBias*(self : UStaticMeshComponentPtr;
newValue : float32): void {.
exportcpp: "$1_".} =
type
Params = object
newValue: float32
var param = Params(newValue: newValue)
let fnName {.used.} = n "SetDistanceFieldSelfShadowBias"
let fn {.used.} = getClassByName("StaticMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc getLocalBounds*(self : UStaticMeshComponentPtr;
min : var FVector; max : var FVector): void {.
exportcpp: "$1_".} =
type
Params = object
min: FVector
max: FVector
var param = Params(min: min, max: max)
let fnName {.used.} = n "GetLocalBounds"
let fn {.used.} = getClassByName("StaticMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
min = param.min
max = param.max
proc getInitialEvaluateWorldPositionOffset*(
self : UStaticMeshComponentPtr): bool {.exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "GetInitialEvaluateWorldPositionOffset"
let fn {.used.} = getClassByName("StaticMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc keepUStaticMeshComponent(fake : UStaticMeshComponent) {.exportcpp.} =
discard
proc scriptedAddFilename*(self : UAssetImportDataPtr;
inPath : FString; index : int32;
sourceFileLabel : FString): void {.
exportcpp: "$1_".} =
type
Params = object
inPath: FString
index: int32
sourceFileLabel: FString
var param = Params(inPath: inPath, index: index,
sourceFileLabel: sourceFileLabel)
let fnName {.used.} = n "ScriptedAddFilename"
let fn {.used.} = getClassByName("AssetImportData").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc getFirstFilename*(self : UAssetImportDataPtr): FString {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FString
var param = Params()
let fnName {.used.} = n "K2_GetFirstFilename"
let fn {.used.} = getClassByName("AssetImportData").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc extractFilenames*(self : UAssetImportDataPtr): TArray[FString] {.
exportcpp: "$1_".} =
type
Params = object
returnValue: TArray[FString]
var param = Params()
let fnName {.used.} = n "K2_ExtractFilenames"
let fn {.used.} = getClassByName("AssetImportData").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc keepUAssetImportData(fake : UAssetImportData) {.exportcpp.} =
discard
proc keepUDebugDrawComponent(fake : UDebugDrawComponent) {.exportcpp.} =
discard
proc keepUAISystemBase(fake : UAISystemBase) {.exportcpp.} =
discard
proc `bUseControllerRotationPitch`*(obj : APawnPtr): bool {.exportcpp.} =
let prop = getClassByName("Pawn").getFPropertyByName(
"bUseControllerRotationPitch")
getValueFromBoolProp(prop, obj)
proc `bUseControllerRotationPitch=`*(obj : APawnPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("Pawn").getFPropertyByName(
"bUseControllerRotationPitch")
setValueInBoolProp(prop, obj, value)
proc `set bUseControllerRotationPitch`*(obj : APawnPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("Pawn").getFPropertyByName(
"bUseControllerRotationPitch")
setValueInBoolProp(prop, obj, value)
proc `bUseControllerRotationYaw`*(obj : APawnPtr): bool {.exportcpp.} =
let prop = getClassByName("Pawn").getFPropertyByName(
"bUseControllerRotationYaw")
getValueFromBoolProp(prop, obj)
proc `bUseControllerRotationYaw=`*(obj : APawnPtr; val : bool) =
var value : bool = val
let prop = getClassByName("Pawn").getFPropertyByName(
"bUseControllerRotationYaw")
setValueInBoolProp(prop, obj, value)
proc `set bUseControllerRotationYaw`*(obj : APawnPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("Pawn").getFPropertyByName(
"bUseControllerRotationYaw")
setValueInBoolProp(prop, obj, value)
proc `bUseControllerRotationRoll`*(obj : APawnPtr): bool {.exportcpp.} =
let prop = getClassByName("Pawn").getFPropertyByName(
"bUseControllerRotationRoll")
getValueFromBoolProp(prop, obj)
proc `bUseControllerRotationRoll=`*(obj : APawnPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("Pawn").getFPropertyByName(
"bUseControllerRotationRoll")
setValueInBoolProp(prop, obj, value)
proc `set bUseControllerRotationRoll`*(obj : APawnPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("Pawn").getFPropertyByName(
"bUseControllerRotationRoll")
setValueInBoolProp(prop, obj, value)
proc `bCanAffectNavigationGeneration`*(obj : APawnPtr): bool {.
exportcpp.} =
let prop = getClassByName("Pawn").getFPropertyByName(
"bCanAffectNavigationGeneration")
getValueFromBoolProp(prop, obj)
proc `bCanAffectNavigationGeneration=`*(obj : APawnPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("Pawn").getFPropertyByName(
"bCanAffectNavigationGeneration")
setValueInBoolProp(prop, obj, value)
proc `set bCanAffectNavigationGeneration`*(obj : APawnPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("Pawn").getFPropertyByName(
"bCanAffectNavigationGeneration")
setValueInBoolProp(prop, obj, value)
proc `baseEyeHeight`*(obj : APawnPtr): float32 {.exportcpp.} =
let prop = getClassByName("Pawn").getFPropertyByName(
"BaseEyeHeight")
getPropertyValuePtr[float32](prop, obj)[]
proc `baseEyeHeight=`*(obj : APawnPtr; val : float32) =
var value : float32 = val
let prop = getClassByName("Pawn").getFPropertyByName(
"BaseEyeHeight")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set baseEyeHeight`*(obj : APawnPtr; val : float32) {.
exportcpp.} =
var value : float32 = val
let prop = getClassByName("Pawn").getFPropertyByName(
"BaseEyeHeight")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `aIControllerClass`*(obj : APawnPtr): TSubclassOf[AController] {.
exportcpp.} =
let prop = getClassByName("Pawn").getFPropertyByName(
"AIControllerClass")
getPropertyValuePtr[TSubclassOf[AController]](prop, obj)[]
proc `aIControllerClass=`*(obj : APawnPtr;
val : TSubclassOf[AController]) =
var value : TSubclassOf[AController] = val
let prop = getClassByName("Pawn").getFPropertyByName(
"AIControllerClass")
setPropertyValuePtr[TSubclassOf[AController]](prop, obj, value.addr)
proc `set aIControllerClass`*(obj : APawnPtr;
val : TSubclassOf[AController]) {.
exportcpp.} =
var value : TSubclassOf[AController] = val
let prop = getClassByName("Pawn").getFPropertyByName(
"AIControllerClass")
setPropertyValuePtr[TSubclassOf[AController]](prop, obj, value.addr)
proc `playerState`*(obj : APawnPtr): APlayerStatePtr {.exportcpp.} =
let prop = getClassByName("Pawn").getFPropertyByName("PlayerState")
getPropertyValuePtr[APlayerStatePtr](prop, obj)[]
proc `playerState=`*(obj : APawnPtr; val : APlayerStatePtr) =
var value : APlayerStatePtr = val
let prop = getClassByName("Pawn").getFPropertyByName("PlayerState")
setPropertyValuePtr[APlayerStatePtr](prop, obj, value.addr)
proc `set playerState`*(obj : APawnPtr; val : APlayerStatePtr) {.
exportcpp.} =
var value : APlayerStatePtr = val
let prop = getClassByName("Pawn").getFPropertyByName("PlayerState")
setPropertyValuePtr[APlayerStatePtr](prop, obj, value.addr)
proc `lastHitBy`*(obj : APawnPtr): AControllerPtr {.exportcpp.} =
let prop = getClassByName("Pawn").getFPropertyByName("LastHitBy")
getPropertyValuePtr[AControllerPtr](prop, obj)[]
proc `lastHitBy=`*(obj : APawnPtr; val : AControllerPtr) =
var value : AControllerPtr = val
let prop = getClassByName("Pawn").getFPropertyByName("LastHitBy")
setPropertyValuePtr[AControllerPtr](prop, obj, value.addr)
proc `set lastHitBy`*(obj : APawnPtr; val : AControllerPtr) {.
exportcpp.} =
var value : AControllerPtr = val
let prop = getClassByName("Pawn").getFPropertyByName("LastHitBy")
setPropertyValuePtr[AControllerPtr](prop, obj, value.addr)
proc spawnDefaultController*(self : APawnPtr): void {.exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "SpawnDefaultController"
let fn {.used.} = getClassByName("Pawn").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc setCanAffectNavigationGeneration*(self : APawnPtr;
bNewValue : bool;
bForceUpdate : bool = false): void {.
exportcpp: "$1_".} =
type
Params = object
bNewValue: bool
bForceUpdate: bool
var param = Params(bNewValue: bNewValue, bForceUpdate: bForceUpdate)
let fnName {.used.} = n "SetCanAffectNavigationGeneration"
let fn {.used.} = getClassByName("Pawn").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc pawnMakeNoise*(self : APawnPtr; loudness : float32;
noiseLocation : FVector;
bUseNoiseMakerLocation : bool = true;
noiseMaker : AActorPtr = nil): void {.
exportcpp: "$1_".} =
type
Params = object
loudness: float32
noiseLocation: FVector
bUseNoiseMakerLocation: bool
noiseMaker: AActorPtr
var param = Params(loudness: loudness,
noiseLocation: noiseLocation,
bUseNoiseMakerLocation: bUseNoiseMakerLocation,
noiseMaker: noiseMaker)
let fnName {.used.} = n "PawnMakeNoise"
let fn {.used.} = getClassByName("Pawn").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc isPlayerControlled*(self : APawnPtr): bool {.exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsPlayerControlled"
let fn {.used.} = getClassByName("Pawn").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isPawnControlled*(self : APawnPtr): bool {.exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsPawnControlled"
let fn {.used.} = getClassByName("Pawn").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isMoveInputIgnored*(self : APawnPtr): bool {.exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsMoveInputIgnored"
let fn {.used.} = getClassByName("Pawn").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isLocallyViewed*(self : APawnPtr): bool {.exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsLocallyViewed"
let fn {.used.} = getClassByName("Pawn").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isLocallyControlled*(self : APawnPtr): bool {.exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsLocallyControlled"
let fn {.used.} = getClassByName("Pawn").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isControlled*(self : APawnPtr): bool {.exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsControlled"
let fn {.used.} = getClassByName("Pawn").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isBotControlled*(self : APawnPtr): bool {.exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsBotControlled"
let fn {.used.} = getClassByName("Pawn").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getPendingMovementInputVector*(self : APawnPtr): FVector {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FVector
var param = Params()
let fnName {.used.} = n "GetPendingMovementInputVector"
let fn {.used.} = getClassByName("Pawn").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getOverrideInputComponentClass*(self : APawnPtr): TSubclassOf[
UInputComponent] {.exportcpp: "$1_".} =
type
Params = object
returnValue: TSubclassOf[UInputComponent]
var param = Params()
let fnName {.used.} = n "GetOverrideInputComponentClass"
let fn {.used.} = getClassByName("Pawn").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getNavAgentLocation*(self : APawnPtr): FVector {.exportcpp: "$1_".} =
type
Params = object
returnValue: FVector
var param = Params()
let fnName {.used.} = n "GetNavAgentLocation"
let fn {.used.} = getClassByName("Pawn").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getMovementComponent*(self : APawnPtr): UPawnMovementComponentPtr {.
exportcpp: "$1_".} =
type
Params = object
returnValue: UPawnMovementComponentPtr
var param = Params()
let fnName {.used.} = n "GetMovementComponent"
let fn {.used.} = getClassByName("Pawn").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getMovementBaseActor*(pawn : APawnPtr): AActorPtr {.
exportcpp: "$1_".} =
type
Params = object
pawn: APawnPtr
returnValue: AActorPtr
var param = Params(pawn: pawn)
let fnName {.used.} = n "GetMovementBaseActor"
let self = getDefaultObjectFromClassName("Pawn")
let fn {.used.} = getClassByName("Pawn").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getLocalViewingPlayerController*(self : APawnPtr): APlayerControllerPtr {.
exportcpp: "$1_".} =
type
Params = object
returnValue: APlayerControllerPtr
var param = Params()
let fnName {.used.} = n "GetLocalViewingPlayerController"
let fn {.used.} = getClassByName("Pawn").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getLastMovementInputVector*(self : APawnPtr): FVector {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FVector
var param = Params()
let fnName {.used.} = n "GetLastMovementInputVector"
let fn {.used.} = getClassByName("Pawn").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getControlRotation*(self : APawnPtr): FRotator {.exportcpp: "$1_".} =
type
Params = object
returnValue: FRotator
var param = Params()
let fnName {.used.} = n "GetControlRotation"
let fn {.used.} = getClassByName("Pawn").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getController*(self : APawnPtr): AControllerPtr {.
exportcpp: "$1_".} =
type
Params = object
returnValue: AControllerPtr
var param = Params()
let fnName {.used.} = n "GetController"
let fn {.used.} = getClassByName("Pawn").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getBaseAimRotation*(self : APawnPtr): FRotator {.exportcpp: "$1_".} =
type
Params = object
returnValue: FRotator
var param = Params()
let fnName {.used.} = n "GetBaseAimRotation"
let fn {.used.} = getClassByName("Pawn").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc detachFromControllerPendingDestroy*(self : APawnPtr): void {.
exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "DetachFromControllerPendingDestroy"
let fn {.used.} = getClassByName("Pawn").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc consumeMovementInputVector*(self : APawnPtr): FVector {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FVector
var param = Params()
let fnName {.used.} = n "ConsumeMovementInputVector"
let fn {.used.} = getClassByName("Pawn").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc addMovementInput*(self : APawnPtr;
worldDirection : FVector;
scaleValue : float32 = 1.0'f32;
bForce : bool = false): void {.exportcpp: "$1_".} =
type
Params = object
worldDirection: FVector
scaleValue: float32
bForce: bool
var param = Params(worldDirection: worldDirection,
scaleValue: scaleValue, bForce: bForce)
let fnName {.used.} = n "AddMovementInput"
let fn {.used.} = getClassByName("Pawn").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc addControllerYawInput*(self : APawnPtr; val : float32): void {.
exportcpp: "$1_".} =
type
Params = object
val: float32
var param = Params(val: val)
let fnName {.used.} = n "AddControllerYawInput"
let fn {.used.} = getClassByName("Pawn").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc addControllerRollInput*(self : APawnPtr; val : float32): void {.
exportcpp: "$1_".} =
type
Params = object
val: float32
var param = Params(val: val)
let fnName {.used.} = n "AddControllerRollInput"
let fn {.used.} = getClassByName("Pawn").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc addControllerPitchInput*(self : APawnPtr; val : float32): void {.
exportcpp: "$1_".} =
type
Params = object
val: float32
var param = Params(val: val)
let fnName {.used.} = n "AddControllerPitchInput"
let fn {.used.} = getClassByName("Pawn").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
proc keepAPawn(fake : APawn) {.exportcpp.} =
discard
converter APawntoUNavAgentInterface*(self : APawnPtr): UNavAgentInterfacePtr =
cast[UNavAgentInterfacePtr](self)
proc `mesh`*(obj : ACharacterPtr): USkeletalMeshComponentPtr {.
exportcpp.} =
let prop = getClassByName("Character").getFPropertyByName("Mesh")
getPropertyValuePtr[USkeletalMeshComponentPtr](prop, obj)[]
proc `mesh=`*(obj : ACharacterPtr;
val : USkeletalMeshComponentPtr) =
var value : USkeletalMeshComponentPtr = val
let prop = getClassByName("Character").getFPropertyByName("Mesh")
setPropertyValuePtr[USkeletalMeshComponentPtr](prop, obj, value.addr)
proc `set mesh`*(obj : ACharacterPtr;
val : USkeletalMeshComponentPtr) {.exportcpp.} =
var value : USkeletalMeshComponentPtr = val
let prop = getClassByName("Character").getFPropertyByName("Mesh")
setPropertyValuePtr[USkeletalMeshComponentPtr](prop, obj, value.addr)
proc `characterMovement`*(obj : ACharacterPtr): UCharacterMovementComponentPtr {.
exportcpp.} =
let prop = getClassByName("Character").getFPropertyByName(
"CharacterMovement")
getPropertyValuePtr[UCharacterMovementComponentPtr](prop, obj)[]
proc `characterMovement=`*(obj : ACharacterPtr;
val : UCharacterMovementComponentPtr) =
var value : UCharacterMovementComponentPtr = val
let prop = getClassByName("Character").getFPropertyByName(
"CharacterMovement")
setPropertyValuePtr[UCharacterMovementComponentPtr](prop, obj, value.addr)
proc `set characterMovement`*(obj : ACharacterPtr;
val : UCharacterMovementComponentPtr) {.
exportcpp.} =
var value : UCharacterMovementComponentPtr = val
let prop = getClassByName("Character").getFPropertyByName(
"CharacterMovement")
setPropertyValuePtr[UCharacterMovementComponentPtr](prop, obj, value.addr)
proc `capsuleComponent`*(obj : ACharacterPtr): UCapsuleComponentPtr {.
exportcpp.} =
let prop = getClassByName("Character").getFPropertyByName(
"CapsuleComponent")
getPropertyValuePtr[UCapsuleComponentPtr](prop, obj)[]
proc `capsuleComponent=`*(obj : ACharacterPtr;
val : UCapsuleComponentPtr) =
var value : UCapsuleComponentPtr = val
let prop = getClassByName("Character").getFPropertyByName(
"CapsuleComponent")
setPropertyValuePtr[UCapsuleComponentPtr](prop, obj, value.addr)
proc `set capsuleComponent`*(obj : ACharacterPtr;
val : UCapsuleComponentPtr) {.exportcpp.} =
var value : UCapsuleComponentPtr = val
let prop = getClassByName("Character").getFPropertyByName(
"CapsuleComponent")
setPropertyValuePtr[UCapsuleComponentPtr](prop, obj, value.addr)
proc `crouchedEyeHeight`*(obj : ACharacterPtr): float32 {.exportcpp.} =
let prop = getClassByName("Character").getFPropertyByName(
"CrouchedEyeHeight")
getPropertyValuePtr[float32](prop, obj)[]
proc `crouchedEyeHeight=`*(obj : ACharacterPtr; val : float32) =
var value : float32 = val
let prop = getClassByName("Character").getFPropertyByName(
"CrouchedEyeHeight")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set crouchedEyeHeight`*(obj : ACharacterPtr;
val : float32) {.exportcpp.} =
var value : float32 = val
let prop = getClassByName("Character").getFPropertyByName(
"CrouchedEyeHeight")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `bIsCrouched`*(obj : ACharacterPtr): bool {.exportcpp.} =
let prop = getClassByName("Character").getFPropertyByName(
"bIsCrouched")
getValueFromBoolProp(prop, obj)
proc `bIsCrouched=`*(obj : ACharacterPtr; val : bool) =
var value : bool = val
let prop = getClassByName("Character").getFPropertyByName(
"bIsCrouched")
setValueInBoolProp(prop, obj, value)
proc `set bIsCrouched`*(obj : ACharacterPtr; val : bool) {.
exportcpp.} =
var value : bool = val
let prop = getClassByName("Character").getFPropertyByName(
"bIsCrouched")
setValueInBoolProp(prop, obj, value)
proc `bPressedJump`*(obj : ACharacterPtr): bool {.exportcpp.} =
let prop = getClassByName("Character").getFPropertyByName(
"bPressedJump")
getValueFromBoolProp(prop, obj)
proc `bPressedJump=`*(obj : ACharacterPtr; val : bool) =
var value : bool = val
let prop = getClassByName("Character").getFPropertyByName(
"bPressedJump")
setValueInBoolProp(prop, obj, value)
proc `set bPressedJump`*(obj : ACharacterPtr; val : bool) {.
exportcpp.} =
var value : bool = val
let prop = getClassByName("Character").getFPropertyByName(
"bPressedJump")
setValueInBoolProp(prop, obj, value)
proc `bWasJumping`*(obj : ACharacterPtr): bool {.exportcpp.} =
let prop = getClassByName("Character").getFPropertyByName(
"bWasJumping")
getValueFromBoolProp(prop, obj)
proc `bWasJumping=`*(obj : ACharacterPtr; val : bool) =
var value : bool = val
let prop = getClassByName("Character").getFPropertyByName(
"bWasJumping")
setValueInBoolProp(prop, obj, value)
proc `set bWasJumping`*(obj : ACharacterPtr; val : bool) {.
exportcpp.} =
var value : bool = val
let prop = getClassByName("Character").getFPropertyByName(
"bWasJumping")
setValueInBoolProp(prop, obj, value)
proc `jumpKeyHoldTime`*(obj : ACharacterPtr): float32 {.exportcpp.} =
let prop = getClassByName("Character").getFPropertyByName(
"JumpKeyHoldTime")
getPropertyValuePtr[float32](prop, obj)[]
proc `jumpKeyHoldTime=`*(obj : ACharacterPtr; val : float32) =
var value : float32 = val
let prop = getClassByName("Character").getFPropertyByName(
"JumpKeyHoldTime")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set jumpKeyHoldTime`*(obj : ACharacterPtr;
val : float32) {.exportcpp.} =
var value : float32 = val
let prop = getClassByName("Character").getFPropertyByName(
"JumpKeyHoldTime")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `jumpForceTimeRemaining`*(obj : ACharacterPtr): float32 {.
exportcpp.} =
let prop = getClassByName("Character").getFPropertyByName(
"JumpForceTimeRemaining")
getPropertyValuePtr[float32](prop, obj)[]
proc `jumpForceTimeRemaining=`*(obj : ACharacterPtr;
val : float32) =
var value : float32 = val
let prop = getClassByName("Character").getFPropertyByName(
"JumpForceTimeRemaining")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set jumpForceTimeRemaining`*(obj : ACharacterPtr;
val : float32) {.exportcpp.} =
var value : float32 = val
let prop = getClassByName("Character").getFPropertyByName(
"JumpForceTimeRemaining")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `proxyJumpForceStartedTime`*(obj : ACharacterPtr): float32 {.
exportcpp.} =
let prop = getClassByName("Character").getFPropertyByName(
"ProxyJumpForceStartedTime")
getPropertyValuePtr[float32](prop, obj)[]
proc `proxyJumpForceStartedTime=`*(obj : ACharacterPtr;
val : float32) =
var value : float32 = val
let prop = getClassByName("Character").getFPropertyByName(
"ProxyJumpForceStartedTime")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set proxyJumpForceStartedTime`*(obj : ACharacterPtr;
val : float32) {.exportcpp.} =
var value : float32 = val
let prop = getClassByName("Character").getFPropertyByName(
"ProxyJumpForceStartedTime")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `jumpMaxHoldTime`*(obj : ACharacterPtr): float32 {.exportcpp.} =
let prop = getClassByName("Character").getFPropertyByName(
"JumpMaxHoldTime")
getPropertyValuePtr[float32](prop, obj)[]
proc `jumpMaxHoldTime=`*(obj : ACharacterPtr; val : float32) =
var value : float32 = val
let prop = getClassByName("Character").getFPropertyByName(
"JumpMaxHoldTime")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set jumpMaxHoldTime`*(obj : ACharacterPtr;
val : float32) {.exportcpp.} =
var value : float32 = val
let prop = getClassByName("Character").getFPropertyByName(
"JumpMaxHoldTime")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `jumpMaxCount`*(obj : ACharacterPtr): int32 {.exportcpp.} =
let prop = getClassByName("Character").getFPropertyByName(
"JumpMaxCount")
getPropertyValuePtr[int32](prop, obj)[]
proc `jumpMaxCount=`*(obj : ACharacterPtr; val : int32) =
var value : int32 = val
let prop = getClassByName("Character").getFPropertyByName(
"JumpMaxCount")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `set jumpMaxCount`*(obj : ACharacterPtr; val : int32) {.
exportcpp.} =
var value : int32 = val
let prop = getClassByName("Character").getFPropertyByName(
"JumpMaxCount")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `jumpCurrentCount`*(obj : ACharacterPtr): int32 {.exportcpp.} =
let prop = getClassByName("Character").getFPropertyByName(
"JumpCurrentCount")
getPropertyValuePtr[int32](prop, obj)[]
proc `jumpCurrentCount=`*(obj : ACharacterPtr; val : int32) =
var value : int32 = val
let prop = getClassByName("Character").getFPropertyByName(
"JumpCurrentCount")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `set jumpCurrentCount`*(obj : ACharacterPtr; val : int32) {.
exportcpp.} =
var value : int32 = val
let prop = getClassByName("Character").getFPropertyByName(
"JumpCurrentCount")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `jumpCurrentCountPreJump`*(obj : ACharacterPtr): int32 {.
exportcpp.} =
let prop = getClassByName("Character").getFPropertyByName(
"JumpCurrentCountPreJump")
getPropertyValuePtr[int32](prop, obj)[]
proc `jumpCurrentCountPreJump=`*(obj : ACharacterPtr;
val : int32) =
var value : int32 = val
let prop = getClassByName("Character").getFPropertyByName(
"JumpCurrentCountPreJump")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `set jumpCurrentCountPreJump`*(obj : ACharacterPtr;
val : int32) {.exportcpp.} =
var value : int32 = val
let prop = getClassByName("Character").getFPropertyByName(
"JumpCurrentCountPreJump")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc unCrouch*(self : ACharacterPtr;
bClientSimulation : bool = false): void {.
exportcpp: "$1_".} =
type
Params = object
bClientSimulation: bool
var param = Params(bClientSimulation: bClientSimulation)
let fnName {.used.} = n "UnCrouch"
let fn {.used.} = getClassByName("Character").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc stopJumping*(self : ACharacterPtr): void {.exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "StopJumping"
let fn {.used.} = getClassByName("Character").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc stopAnimMontage*(self : ACharacterPtr;
animMontage : UAnimMontagePtr = nil): void {.
exportcpp: "$1_".} =
type
Params = object
animMontage: UAnimMontagePtr
var param = Params(animMontage: animMontage)
let fnName {.used.} = n "StopAnimMontage"
let fn {.used.} = getClassByName("Character").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc playAnimMontage*(self : ACharacterPtr;
animMontage : UAnimMontagePtr;
inPlayRate : float32 = 1.0'f32;
startSectionName : FName = makeFName("None")): float32 {.
exportcpp: "$1_".} =
type
Params = object
animMontage: UAnimMontagePtr
inPlayRate: float32
startSectionName: FName
returnValue: float32
var param = Params(animMontage: animMontage,
inPlayRate: inPlayRate,
startSectionName: startSectionName)
let fnName {.used.} = n "PlayAnimMontage"
let fn {.used.} = getClassByName("Character").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc launchCharacter*(self : ACharacterPtr;
launchVelocity : FVector;
bXYOverride : bool; bZOverride : bool): void {.
exportcpp: "$1_".} =
type
Params = object
launchVelocity: FVector
bXYOverride: bool
bZOverride: bool
var param = Params(launchVelocity: launchVelocity,
bXYOverride: bXYOverride, bZOverride: bZOverride)
let fnName {.used.} = n "LaunchCharacter"
let fn {.used.} = getClassByName("Character").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc jump*(self : ACharacterPtr): void {.exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "Jump"
let fn {.used.} = getClassByName("Character").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc isPlayingRootMotion*(self : ACharacterPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsPlayingRootMotion"
let fn {.used.} = getClassByName("Character").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isPlayingNetworkedRootMotionMontage*(self : ACharacterPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsPlayingNetworkedRootMotionMontage"
let fn {.used.} = getClassByName("Character").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isJumpProvidingForce*(self : ACharacterPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsJumpProvidingForce"
let fn {.used.} = getClassByName("Character").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc hasAnyRootMotion*(self : ACharacterPtr): bool {.exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "HasAnyRootMotion"
let fn {.used.} = getClassByName("Character").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getCurrentMontage*(self : ACharacterPtr): UAnimMontagePtr {.
exportcpp: "$1_".} =
type
Params = object
returnValue: UAnimMontagePtr
var param = Params()
let fnName {.used.} = n "GetCurrentMontage"
let fn {.used.} = getClassByName("Character").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getBaseTranslationOffset*(self : ACharacterPtr): FVector {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FVector
var param = Params()
let fnName {.used.} = n "GetBaseTranslationOffset"
let fn {.used.} = getClassByName("Character").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getBaseRotationOffsetRotator*(self : ACharacterPtr): FRotator {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FRotator
var param = Params()
let fnName {.used.} = n "GetBaseRotationOffsetRotator"
let fn {.used.} = getClassByName("Character").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getAnimRootMotionTranslationScale*(self : ACharacterPtr): float32 {.
exportcpp: "$1_".} =
type
Params = object
returnValue: float32
var param = Params()
let fnName {.used.} = n "GetAnimRootMotionTranslationScale"
let fn {.used.} = getClassByName("Character").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc crouch*(self : ACharacterPtr;
bClientSimulation : bool = false): void {.
exportcpp: "$1_".} =
type
Params = object
bClientSimulation: bool
var param = Params(bClientSimulation: bClientSimulation)
let fnName {.used.} = n "Crouch"
let fn {.used.} = getClassByName("Character").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc canJump*(self : ACharacterPtr): bool {.exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "CanJump"
let fn {.used.} = getClassByName("Character").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc canCrouch*(self : ACharacterPtr): bool {.exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "CanCrouch"
let fn {.used.} = getClassByName("Character").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc cacheInitialMeshOffset*(self : ACharacterPtr;
meshRelativeLocation : FVector;
meshRelativeRotation : FRotator): void {.
exportcpp: "$1_".} =
type
Params = object
meshRelativeLocation: FVector
meshRelativeRotation: FRotator
var param = Params(meshRelativeLocation: meshRelativeLocation,
meshRelativeRotation: meshRelativeRotation)
let fnName {.used.} = n "CacheInitialMeshOffset"
let fn {.used.} = getClassByName("Character").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc keepACharacter(fake : ACharacter) {.exportcpp.} =
discard
proc keepUNavLinkDefinition(fake : UNavLinkDefinition) {.exportcpp.} =
discard
proc keepUNavAreaBase(fake : UNavAreaBase) {.exportcpp.} =
discard
proc keepUNavCollisionBase(fake : UNavCollisionBase) {.exportcpp.} =
discard
proc getWorldSettings*(self : UWorldPtr): AWorldSettingsPtr {.
exportcpp: "$1_".} =
type
Params = object
returnValue: AWorldSettingsPtr
var param = Params()
let fnName {.used.} = n "K2_GetWorldSettings"
let fn {.used.} = getClassByName("World").findFunctionByName(fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc keepUWorld(fake : UWorld) {.exportcpp.} =
discard
proc keepUNavigationSystemBase(fake : UNavigationSystemBase) {.
exportcpp.} =
discard
proc keepAVolume(fake : AVolume) {.exportcpp.} =
discard
proc keepUNavigationDataChunk(fake : UNavigationDataChunk) {.exportcpp.} =
discard
proc `cameraComponent`*(obj : ACameraActorPtr): UCameraComponentPtr {.
exportcpp.} =
let prop = getClassByName("CameraActor").getFPropertyByName(
"CameraComponent")
getPropertyValuePtr[UCameraComponentPtr](prop, obj)[]
proc `cameraComponent=`*(obj : ACameraActorPtr;
val : UCameraComponentPtr) =
var value : UCameraComponentPtr = val
let prop = getClassByName("CameraActor").getFPropertyByName(
"CameraComponent")
setPropertyValuePtr[UCameraComponentPtr](prop, obj, value.addr)
proc `set cameraComponent`*(obj : ACameraActorPtr;
val : UCameraComponentPtr) {.exportcpp.} =
var value : UCameraComponentPtr = val
let prop = getClassByName("CameraActor").getFPropertyByName(
"CameraComponent")
setPropertyValuePtr[UCameraComponentPtr](prop, obj, value.addr)
proc `sceneComponent`*(obj : ACameraActorPtr): USceneComponentPtr {.
exportcpp.} =
let prop = getClassByName("CameraActor").getFPropertyByName(
"SceneComponent")
getPropertyValuePtr[USceneComponentPtr](prop, obj)[]
proc `sceneComponent=`*(obj : ACameraActorPtr;
val : USceneComponentPtr) =
var value : USceneComponentPtr = val
let prop = getClassByName("CameraActor").getFPropertyByName(
"SceneComponent")
setPropertyValuePtr[USceneComponentPtr](prop, obj, value.addr)
proc `set sceneComponent`*(obj : ACameraActorPtr;
val : USceneComponentPtr) {.exportcpp.} =
var value : USceneComponentPtr = val
let prop = getClassByName("CameraActor").getFPropertyByName(
"SceneComponent")
setPropertyValuePtr[USceneComponentPtr](prop, obj, value.addr)
proc getAutoActivatePlayerIndex*(self : ACameraActorPtr): int32 {.
exportcpp: "$1_".} =
type
Params = object
returnValue: int32
var param = Params()
let fnName {.used.} = n "GetAutoActivatePlayerIndex"
let fn {.used.} = getClassByName("CameraActor").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc keepACameraActor(fake : ACameraActor) {.exportcpp.} =
discard
proc `fieldOfView`*(obj : UCameraComponentPtr): float32 {.exportcpp.} =
let prop = getClassByName("CameraComponent").getFPropertyByName(
"FieldOfView")
getPropertyValuePtr[float32](prop, obj)[]
proc `fieldOfView=`*(obj : UCameraComponentPtr; val : float32) =
var value : float32 = val
let prop = getClassByName("CameraComponent").getFPropertyByName(
"FieldOfView")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set fieldOfView`*(obj : UCameraComponentPtr;
val : float32) {.exportcpp.} =
var value : float32 = val
let prop = getClassByName("CameraComponent").getFPropertyByName(
"FieldOfView")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `orthoWidth`*(obj : UCameraComponentPtr): float32 {.exportcpp.} =
let prop = getClassByName("CameraComponent").getFPropertyByName(
"OrthoWidth")
getPropertyValuePtr[float32](prop, obj)[]
proc `orthoWidth=`*(obj : UCameraComponentPtr; val : float32) =
var value : float32 = val
let prop = getClassByName("CameraComponent").getFPropertyByName(
"OrthoWidth")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set orthoWidth`*(obj : UCameraComponentPtr;
val : float32) {.exportcpp.} =
var value : float32 = val
let prop = getClassByName("CameraComponent").getFPropertyByName(
"OrthoWidth")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `orthoNearClipPlane`*(obj : UCameraComponentPtr): float32 {.
exportcpp.} =
let prop = getClassByName("CameraComponent").getFPropertyByName(
"OrthoNearClipPlane")
getPropertyValuePtr[float32](prop, obj)[]
proc `orthoNearClipPlane=`*(obj : UCameraComponentPtr;
val : float32) =
var value : float32 = val
let prop = getClassByName("CameraComponent").getFPropertyByName(
"OrthoNearClipPlane")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set orthoNearClipPlane`*(obj : UCameraComponentPtr;
val : float32) {.exportcpp.} =
var value : float32 = val
let prop = getClassByName("CameraComponent").getFPropertyByName(
"OrthoNearClipPlane")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `orthoFarClipPlane`*(obj : UCameraComponentPtr): float32 {.
exportcpp.} =
let prop = getClassByName("CameraComponent").getFPropertyByName(
"OrthoFarClipPlane")
getPropertyValuePtr[float32](prop, obj)[]
proc `orthoFarClipPlane=`*(obj : UCameraComponentPtr;
val : float32) =
var value : float32 = val
let prop = getClassByName("CameraComponent").getFPropertyByName(
"OrthoFarClipPlane")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set orthoFarClipPlane`*(obj : UCameraComponentPtr;
val : float32) {.exportcpp.} =
var value : float32 = val
let prop = getClassByName("CameraComponent").getFPropertyByName(
"OrthoFarClipPlane")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `aspectRatio`*(obj : UCameraComponentPtr): float32 {.exportcpp.} =
let prop = getClassByName("CameraComponent").getFPropertyByName(
"AspectRatio")
getPropertyValuePtr[float32](prop, obj)[]
proc `aspectRatio=`*(obj : UCameraComponentPtr; val : float32) =
var value : float32 = val
let prop = getClassByName("CameraComponent").getFPropertyByName(
"AspectRatio")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set aspectRatio`*(obj : UCameraComponentPtr;
val : float32) {.exportcpp.} =
var value : float32 = val
let prop = getClassByName("CameraComponent").getFPropertyByName(
"AspectRatio")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `bConstrainAspectRatio`*(obj : UCameraComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("CameraComponent").getFPropertyByName(
"bConstrainAspectRatio")
getValueFromBoolProp(prop, obj)
proc `bConstrainAspectRatio=`*(obj : UCameraComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("CameraComponent").getFPropertyByName(
"bConstrainAspectRatio")
setValueInBoolProp(prop, obj, value)
proc `set bConstrainAspectRatio`*(obj : UCameraComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("CameraComponent").getFPropertyByName(
"bConstrainAspectRatio")
setValueInBoolProp(prop, obj, value)
proc `bUseFieldOfViewForLOD`*(obj : UCameraComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("CameraComponent").getFPropertyByName(
"bUseFieldOfViewForLOD")
getValueFromBoolProp(prop, obj)
proc `bUseFieldOfViewForLOD=`*(obj : UCameraComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("CameraComponent").getFPropertyByName(
"bUseFieldOfViewForLOD")
setValueInBoolProp(prop, obj, value)
proc `set bUseFieldOfViewForLOD`*(obj : UCameraComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("CameraComponent").getFPropertyByName(
"bUseFieldOfViewForLOD")
setValueInBoolProp(prop, obj, value)
proc `bDrawFrustumAllowed`*(obj : UCameraComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("CameraComponent").getFPropertyByName(
"bDrawFrustumAllowed")
getValueFromBoolProp(prop, obj)
proc `bDrawFrustumAllowed=`*(obj : UCameraComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("CameraComponent").getFPropertyByName(
"bDrawFrustumAllowed")
setValueInBoolProp(prop, obj, value)
proc `set bDrawFrustumAllowed`*(obj : UCameraComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("CameraComponent").getFPropertyByName(
"bDrawFrustumAllowed")
setValueInBoolProp(prop, obj, value)
proc `bCameraMeshHiddenInGame`*(obj : UCameraComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("CameraComponent").getFPropertyByName(
"bCameraMeshHiddenInGame")
getValueFromBoolProp(prop, obj)
proc `bCameraMeshHiddenInGame=`*(obj : UCameraComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("CameraComponent").getFPropertyByName(
"bCameraMeshHiddenInGame")
setValueInBoolProp(prop, obj, value)
proc `set bCameraMeshHiddenInGame`*(obj : UCameraComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("CameraComponent").getFPropertyByName(
"bCameraMeshHiddenInGame")
setValueInBoolProp(prop, obj, value)
proc `bLockToHmd`*(obj : UCameraComponentPtr): bool {.exportcpp.} =
let prop = getClassByName("CameraComponent").getFPropertyByName(
"bLockToHmd")
getValueFromBoolProp(prop, obj)
proc `bLockToHmd=`*(obj : UCameraComponentPtr; val : bool) =
var value : bool = val
let prop = getClassByName("CameraComponent").getFPropertyByName(
"bLockToHmd")
setValueInBoolProp(prop, obj, value)
proc `set bLockToHmd`*(obj : UCameraComponentPtr; val : bool) {.
exportcpp.} =
var value : bool = val
let prop = getClassByName("CameraComponent").getFPropertyByName(
"bLockToHmd")
setValueInBoolProp(prop, obj, value)
proc `bUsePawnControlRotation`*(obj : UCameraComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("CameraComponent").getFPropertyByName(
"bUsePawnControlRotation")
getValueFromBoolProp(prop, obj)
proc `bUsePawnControlRotation=`*(obj : UCameraComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("CameraComponent").getFPropertyByName(
"bUsePawnControlRotation")
setValueInBoolProp(prop, obj, value)
proc `set bUsePawnControlRotation`*(obj : UCameraComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("CameraComponent").getFPropertyByName(
"bUsePawnControlRotation")
setValueInBoolProp(prop, obj, value)
proc `projectionMode`*(obj : UCameraComponentPtr): ECameraProjectionMode {.
exportcpp.} =
let prop = getClassByName("CameraComponent").getFPropertyByName(
"ProjectionMode")
getPropertyValuePtr[ECameraProjectionMode](prop, obj)[]
proc `projectionMode=`*(obj : UCameraComponentPtr;
val : ECameraProjectionMode) =
var value : ECameraProjectionMode = val
let prop = getClassByName("CameraComponent").getFPropertyByName(
"ProjectionMode")
setPropertyValuePtr[ECameraProjectionMode](prop, obj, value.addr)
proc `set projectionMode`*(obj : UCameraComponentPtr;
val : ECameraProjectionMode) {.
exportcpp.} =
var value : ECameraProjectionMode = val
let prop = getClassByName("CameraComponent").getFPropertyByName(
"ProjectionMode")
setPropertyValuePtr[ECameraProjectionMode](prop, obj, value.addr)
proc `cameraMesh`*(obj : UCameraComponentPtr): UStaticMeshPtr {.
exportcpp.} =
let prop = getClassByName("CameraComponent").getFPropertyByName(
"CameraMesh")
getPropertyValuePtr[UStaticMeshPtr](prop, obj)[]
proc `cameraMesh=`*(obj : UCameraComponentPtr;
val : UStaticMeshPtr) =
var value : UStaticMeshPtr = val
let prop = getClassByName("CameraComponent").getFPropertyByName(
"CameraMesh")
setPropertyValuePtr[UStaticMeshPtr](prop, obj, value.addr)
proc `set cameraMesh`*(obj : UCameraComponentPtr;
val : UStaticMeshPtr) {.exportcpp.} =
var value : UStaticMeshPtr = val
let prop = getClassByName("CameraComponent").getFPropertyByName(
"CameraMesh")
setPropertyValuePtr[UStaticMeshPtr](prop, obj, value.addr)
proc `postProcessBlendWeight`*(obj : UCameraComponentPtr): float32 {.
exportcpp.} =
let prop = getClassByName("CameraComponent").getFPropertyByName(
"PostProcessBlendWeight")
getPropertyValuePtr[float32](prop, obj)[]
proc `postProcessBlendWeight=`*(obj : UCameraComponentPtr;
val : float32) =
var value : float32 = val
let prop = getClassByName("CameraComponent").getFPropertyByName(
"PostProcessBlendWeight")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set postProcessBlendWeight`*(obj : UCameraComponentPtr;
val : float32) {.exportcpp.} =
var value : float32 = val
let prop = getClassByName("CameraComponent").getFPropertyByName(
"PostProcessBlendWeight")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `postProcessSettings`*(obj : UCameraComponentPtr): var FPostProcessSettings {.
exportcpp.} =
let prop = getClassByName("CameraComponent").getFPropertyByName(
"PostProcessSettings")
getPropertyValuePtr[FPostProcessSettings](prop, obj)[]
proc `postProcessSettings=`*(obj : UCameraComponentPtr;
val : FPostProcessSettings) =
var value : FPostProcessSettings = val
let prop = getClassByName("CameraComponent").getFPropertyByName(
"PostProcessSettings")
setPropertyValuePtr[FPostProcessSettings](prop, obj, value.addr)
proc `set postProcessSettings`*(obj : UCameraComponentPtr;
val : FPostProcessSettings) {.
exportcpp.} =
var value : FPostProcessSettings = val
let prop = getClassByName("CameraComponent").getFPropertyByName(
"PostProcessSettings")
setPropertyValuePtr[FPostProcessSettings](prop, obj, value.addr)
proc setUseFieldOfViewForLOD*(self : UCameraComponentPtr;
bInUseFieldOfViewForLOD : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bInUseFieldOfViewForLOD: bool
var param = Params(bInUseFieldOfViewForLOD: bInUseFieldOfViewForLOD)
let fnName {.used.} = n "SetUseFieldOfViewForLOD"
let fn {.used.} = getClassByName("CameraComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setProjectionMode*(self : UCameraComponentPtr;
inProjectionMode : ECameraProjectionMode): void {.
exportcpp: "$1_".} =
type
Params = object
inProjectionMode: ECameraProjectionMode
var param = Params(inProjectionMode: inProjectionMode)
let fnName {.used.} = n "SetProjectionMode"
let fn {.used.} = getClassByName("CameraComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setPostProcessBlendWeight*(self : UCameraComponentPtr;
inPostProcessBlendWeight : float32): void {.
exportcpp: "$1_".} =
type
Params = object
inPostProcessBlendWeight: float32
var param = Params(inPostProcessBlendWeight: inPostProcessBlendWeight)
let fnName {.used.} = n "SetPostProcessBlendWeight"
let fn {.used.} = getClassByName("CameraComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setOrthoWidth*(self : UCameraComponentPtr;
inOrthoWidth : float32): void {.exportcpp: "$1_".} =
type
Params = object
inOrthoWidth: float32
var param = Params(inOrthoWidth: inOrthoWidth)
let fnName {.used.} = n "SetOrthoWidth"
let fn {.used.} = getClassByName("CameraComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setOrthoNearClipPlane*(self : UCameraComponentPtr;
inOrthoNearClipPlane : float32): void {.
exportcpp: "$1_".} =
type
Params = object
inOrthoNearClipPlane: float32
var param = Params(inOrthoNearClipPlane: inOrthoNearClipPlane)
let fnName {.used.} = n "SetOrthoNearClipPlane"
let fn {.used.} = getClassByName("CameraComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setOrthoFarClipPlane*(self : UCameraComponentPtr;
inOrthoFarClipPlane : float32): void {.
exportcpp: "$1_".} =
type
Params = object
inOrthoFarClipPlane: float32
var param = Params(inOrthoFarClipPlane: inOrthoFarClipPlane)
let fnName {.used.} = n "SetOrthoFarClipPlane"
let fn {.used.} = getClassByName("CameraComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setFieldOfView*(self : UCameraComponentPtr;
inFieldOfView : float32): void {.exportcpp: "$1_".} =
type
Params = object
inFieldOfView: float32
var param = Params(inFieldOfView: inFieldOfView)
let fnName {.used.} = n "SetFieldOfView"
let fn {.used.} = getClassByName("CameraComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setConstraintAspectRatio*(self : UCameraComponentPtr;
bInConstrainAspectRatio : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bInConstrainAspectRatio: bool
var param = Params(bInConstrainAspectRatio: bInConstrainAspectRatio)
let fnName {.used.} = n "SetConstraintAspectRatio"
let fn {.used.} = getClassByName("CameraComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setAspectRatio*(self : UCameraComponentPtr;
inAspectRatio : float32): void {.exportcpp: "$1_".} =
type
Params = object
inAspectRatio: float32
var param = Params(inAspectRatio: inAspectRatio)
let fnName {.used.} = n "SetAspectRatio"
let fn {.used.} = getClassByName("CameraComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc removeBlendable*(self : UCameraComponentPtr;
inBlendableObject : TScriptInterface[UBlendableInterface]): void {.
exportcpp: "$1_".} =
type
Params = object
inBlendableObject: TScriptInterface[UBlendableInterface]
var param = Params(inBlendableObject: inBlendableObject)
let fnName {.used.} = n "RemoveBlendable"
let fn {.used.} = getClassByName("CameraComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc onCameraMeshHiddenChanged*(self : UCameraComponentPtr): void {.
exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "OnCameraMeshHiddenChanged"
let fn {.used.} = getClassByName("CameraComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc getCameraView*(self : UCameraComponentPtr;
deltaTime : float32;
desiredView : var FMinimalViewInfo): void {.
exportcpp: "$1_".} =
type
Params = object
deltaTime: float32
desiredView: FMinimalViewInfo
var param = Params(deltaTime: deltaTime, desiredView: desiredView)
let fnName {.used.} = n "GetCameraView"
let fn {.used.} = getClassByName("CameraComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
desiredView = param.desiredView
proc addOrUpdateBlendable*(self : UCameraComponentPtr;
inBlendableObject : TScriptInterface[UBlendableInterface];
inWeight : float32 = 1.0'f32): void {.
exportcpp: "$1_".} =
type
Params = object
inBlendableObject: TScriptInterface[UBlendableInterface]
inWeight: float32
var param = Params(inBlendableObject: inBlendableObject,
inWeight: inWeight)
let fnName {.used.} = n "AddOrUpdateBlendable"
let fn {.used.} = getClassByName("CameraComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc keepUCameraComponent(fake : UCameraComponent) {.exportcpp.} =
discard
proc keepUEngineSubsystem(fake : UEngineSubsystem) {.exportcpp.} =
discard
proc keepUDynamicBlueprintBinding(fake : UDynamicBlueprintBinding) {.
exportcpp.} =
discard
proc keepUGameInstance(fake : UGameInstance) {.exportcpp.} =
discard
proc keepUGameInstanceSubsystem(fake : UGameInstanceSubsystem) {.
exportcpp.} =
discard
proc keepUEdGraphSchema(fake : UEdGraphSchema) {.exportcpp.} =
discard
proc `skeletalMesh`*(obj : USkinnedMeshComponentPtr): USkeletalMeshPtr {.
exportcpp.} =
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"SkeletalMesh")
getPropertyValuePtr[USkeletalMeshPtr](prop, obj)[]
proc `skeletalMesh=`*(obj : USkinnedMeshComponentPtr;
val : USkeletalMeshPtr) =
var value : USkeletalMeshPtr = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"SkeletalMesh")
setPropertyValuePtr[USkeletalMeshPtr](prop, obj, value.addr)
proc `set skeletalMesh`*(obj : USkinnedMeshComponentPtr;
val : USkeletalMeshPtr) {.exportcpp.} =
var value : USkeletalMeshPtr = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"SkeletalMesh")
setPropertyValuePtr[USkeletalMeshPtr](prop, obj, value.addr)
proc `skinnedAsset`*(obj : USkinnedMeshComponentPtr): USkinnedAssetPtr {.
exportcpp.} =
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"SkinnedAsset")
getPropertyValuePtr[USkinnedAssetPtr](prop, obj)[]
proc `skinnedAsset=`*(obj : USkinnedMeshComponentPtr;
val : USkinnedAssetPtr) =
var value : USkinnedAssetPtr = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"SkinnedAsset")
setPropertyValuePtr[USkinnedAssetPtr](prop, obj, value.addr)
proc `set skinnedAsset`*(obj : USkinnedMeshComponentPtr;
val : USkinnedAssetPtr) {.exportcpp.} =
var value : USkinnedAssetPtr = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"SkinnedAsset")
setPropertyValuePtr[USkinnedAssetPtr](prop, obj, value.addr)
proc `leaderPoseComponent`*(obj : USkinnedMeshComponentPtr): TWeakObjectPtr[
USkinnedMeshComponent] {.exportcpp.} =
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"LeaderPoseComponent")
getPropertyValuePtr[TWeakObjectPtr[USkinnedMeshComponent]](prop, obj)[]
proc `leaderPoseComponent=`*(obj : USkinnedMeshComponentPtr;
val : TWeakObjectPtr[USkinnedMeshComponent]) =
var value : TWeakObjectPtr[USkinnedMeshComponent] = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"LeaderPoseComponent")
setPropertyValuePtr[TWeakObjectPtr[USkinnedMeshComponent]](prop, obj,
value.addr)
proc `set leaderPoseComponent`*(obj : USkinnedMeshComponentPtr;
val : TWeakObjectPtr[USkinnedMeshComponent]) {.exportcpp.} =
var value : TWeakObjectPtr[USkinnedMeshComponent] = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"LeaderPoseComponent")
setPropertyValuePtr[TWeakObjectPtr[USkinnedMeshComponent]](prop, obj,
value.addr)
proc `skinCacheUsage`*(obj : USkinnedMeshComponentPtr): var TArray[
ESkinCacheUsage] {.exportcpp.} =
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"SkinCacheUsage")
getPropertyValuePtr[TArray[ESkinCacheUsage]](prop, obj)[]
proc `skinCacheUsage=`*(obj : USkinnedMeshComponentPtr;
val : TArray[ESkinCacheUsage]) =
var value : TArray[ESkinCacheUsage] = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"SkinCacheUsage")
setPropertyValuePtr[TArray[ESkinCacheUsage]](prop, obj, value.addr)
proc `set skinCacheUsage`*(obj : USkinnedMeshComponentPtr;
val : TArray[ESkinCacheUsage]) {.exportcpp.} =
var value : TArray[ESkinCacheUsage] = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"SkinCacheUsage")
setPropertyValuePtr[TArray[ESkinCacheUsage]](prop, obj, value.addr)
proc `bSetMeshDeformer`*(obj : USkinnedMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bSetMeshDeformer")
getValueFromBoolProp(prop, obj)
proc `bSetMeshDeformer=`*(obj : USkinnedMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bSetMeshDeformer")
setValueInBoolProp(prop, obj, value)
proc `set bSetMeshDeformer`*(obj : USkinnedMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bSetMeshDeformer")
setValueInBoolProp(prop, obj, value)
proc `meshDeformer`*(obj : USkinnedMeshComponentPtr): UMeshDeformerPtr {.
exportcpp.} =
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"MeshDeformer")
getPropertyValuePtr[UMeshDeformerPtr](prop, obj)[]
proc `meshDeformer=`*(obj : USkinnedMeshComponentPtr;
val : UMeshDeformerPtr) =
var value : UMeshDeformerPtr = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"MeshDeformer")
setPropertyValuePtr[UMeshDeformerPtr](prop, obj, value.addr)
proc `set meshDeformer`*(obj : USkinnedMeshComponentPtr;
val : UMeshDeformerPtr) {.exportcpp.} =
var value : UMeshDeformerPtr = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"MeshDeformer")
setPropertyValuePtr[UMeshDeformerPtr](prop, obj, value.addr)
proc `meshDeformerInstanceSettings`*(obj : USkinnedMeshComponentPtr): UMeshDeformerInstanceSettingsPtr {.
exportcpp.} =
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"MeshDeformerInstanceSettings")
getPropertyValuePtr[UMeshDeformerInstanceSettingsPtr](prop, obj)[]
proc `meshDeformerInstanceSettings=`*(obj : USkinnedMeshComponentPtr;
val : UMeshDeformerInstanceSettingsPtr) =
var value : UMeshDeformerInstanceSettingsPtr = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"MeshDeformerInstanceSettings")
setPropertyValuePtr[UMeshDeformerInstanceSettingsPtr](prop, obj, value.addr)
proc `set meshDeformerInstanceSettings`*(
obj : USkinnedMeshComponentPtr;
val : UMeshDeformerInstanceSettingsPtr) {.exportcpp.} =
var value : UMeshDeformerInstanceSettingsPtr = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"MeshDeformerInstanceSettings")
setPropertyValuePtr[UMeshDeformerInstanceSettingsPtr](prop, obj, value.addr)
proc `meshDeformerInstance`*(obj : USkinnedMeshComponentPtr): UMeshDeformerInstancePtr {.
exportcpp.} =
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"MeshDeformerInstance")
getPropertyValuePtr[UMeshDeformerInstancePtr](prop, obj)[]
proc `meshDeformerInstance=`*(obj : USkinnedMeshComponentPtr;
val : UMeshDeformerInstancePtr) =
var value : UMeshDeformerInstancePtr = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"MeshDeformerInstance")
setPropertyValuePtr[UMeshDeformerInstancePtr](prop, obj, value.addr)
proc `set meshDeformerInstance`*(obj : USkinnedMeshComponentPtr;
val : UMeshDeformerInstancePtr) {.
exportcpp.} =
var value : UMeshDeformerInstancePtr = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"MeshDeformerInstance")
setPropertyValuePtr[UMeshDeformerInstancePtr](prop, obj, value.addr)
proc `physicsAssetOverride`*(obj : USkinnedMeshComponentPtr): UPhysicsAssetPtr {.
exportcpp.} =
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"PhysicsAssetOverride")
getPropertyValuePtr[UPhysicsAssetPtr](prop, obj)[]
proc `physicsAssetOverride=`*(obj : USkinnedMeshComponentPtr;
val : UPhysicsAssetPtr) =
var value : UPhysicsAssetPtr = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"PhysicsAssetOverride")
setPropertyValuePtr[UPhysicsAssetPtr](prop, obj, value.addr)
proc `set physicsAssetOverride`*(obj : USkinnedMeshComponentPtr;
val : UPhysicsAssetPtr) {.exportcpp.} =
var value : UPhysicsAssetPtr = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"PhysicsAssetOverride")
setPropertyValuePtr[UPhysicsAssetPtr](prop, obj, value.addr)
proc `forcedLodModel`*(obj : USkinnedMeshComponentPtr): int32 {.
exportcpp.} =
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"ForcedLodModel")
getPropertyValuePtr[int32](prop, obj)[]
proc `forcedLodModel=`*(obj : USkinnedMeshComponentPtr;
val : int32) =
var value : int32 = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"ForcedLodModel")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `set forcedLodModel`*(obj : USkinnedMeshComponentPtr;
val : int32) {.exportcpp.} =
var value : int32 = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"ForcedLodModel")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `minLodModel`*(obj : USkinnedMeshComponentPtr): int32 {.exportcpp.} =
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"MinLodModel")
getPropertyValuePtr[int32](prop, obj)[]
proc `minLodModel=`*(obj : USkinnedMeshComponentPtr;
val : int32) =
var value : int32 = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"MinLodModel")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `set minLodModel`*(obj : USkinnedMeshComponentPtr;
val : int32) {.exportcpp.} =
var value : int32 = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"MinLodModel")
setPropertyValuePtr[int32](prop, obj, value.addr)
proc `streamingDistanceMultiplier`*(obj : USkinnedMeshComponentPtr): float32 {.
exportcpp.} =
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"StreamingDistanceMultiplier")
getPropertyValuePtr[float32](prop, obj)[]
proc `streamingDistanceMultiplier=`*(obj : USkinnedMeshComponentPtr;
val : float32) =
var value : float32 = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"StreamingDistanceMultiplier")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set streamingDistanceMultiplier`*(obj : USkinnedMeshComponentPtr;
val : float32) {.exportcpp.} =
var value : float32 = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"StreamingDistanceMultiplier")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `visibilityBasedAnimTickOption`*(obj : USkinnedMeshComponentPtr): EVisibilityBasedAnimTickOption {.
exportcpp.} =
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"VisibilityBasedAnimTickOption")
getPropertyValuePtr[EVisibilityBasedAnimTickOption](prop, obj)[]
proc `visibilityBasedAnimTickOption=`*(obj : USkinnedMeshComponentPtr;
val : EVisibilityBasedAnimTickOption) =
var value : EVisibilityBasedAnimTickOption = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"VisibilityBasedAnimTickOption")
setPropertyValuePtr[EVisibilityBasedAnimTickOption](prop, obj, value.addr)
proc `set visibilityBasedAnimTickOption`*(
obj : USkinnedMeshComponentPtr;
val : EVisibilityBasedAnimTickOption) {.exportcpp.} =
var value : EVisibilityBasedAnimTickOption = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"VisibilityBasedAnimTickOption")
setPropertyValuePtr[EVisibilityBasedAnimTickOption](prop, obj, value.addr)
proc `bOverrideMinLod`*(obj : USkinnedMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bOverrideMinLod")
getValueFromBoolProp(prop, obj)
proc `bOverrideMinLod=`*(obj : USkinnedMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bOverrideMinLod")
setValueInBoolProp(prop, obj, value)
proc `set bOverrideMinLod`*(obj : USkinnedMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bOverrideMinLod")
setValueInBoolProp(prop, obj, value)
proc `bUseBoundsFromLeaderPoseComponent`*(
obj : USkinnedMeshComponentPtr): bool {.exportcpp.} =
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bUseBoundsFromLeaderPoseComponent")
getValueFromBoolProp(prop, obj)
proc `bUseBoundsFromLeaderPoseComponent=`*(
obj : USkinnedMeshComponentPtr; val : bool) =
var value : bool = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bUseBoundsFromLeaderPoseComponent")
setValueInBoolProp(prop, obj, value)
proc `set bUseBoundsFromLeaderPoseComponent`*(
obj : USkinnedMeshComponentPtr; val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bUseBoundsFromLeaderPoseComponent")
setValueInBoolProp(prop, obj, value)
proc `bDisableMorphTarget`*(obj : USkinnedMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bDisableMorphTarget")
getValueFromBoolProp(prop, obj)
proc `bDisableMorphTarget=`*(obj : USkinnedMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bDisableMorphTarget")
setValueInBoolProp(prop, obj, value)
proc `set bDisableMorphTarget`*(obj : USkinnedMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bDisableMorphTarget")
setValueInBoolProp(prop, obj, value)
proc `bPerBoneMotionBlur`*(obj : USkinnedMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bPerBoneMotionBlur")
getValueFromBoolProp(prop, obj)
proc `bPerBoneMotionBlur=`*(obj : USkinnedMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bPerBoneMotionBlur")
setValueInBoolProp(prop, obj, value)
proc `set bPerBoneMotionBlur`*(obj : USkinnedMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bPerBoneMotionBlur")
setValueInBoolProp(prop, obj, value)
proc `bComponentUseFixedSkelBounds`*(obj : USkinnedMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bComponentUseFixedSkelBounds")
getValueFromBoolProp(prop, obj)
proc `bComponentUseFixedSkelBounds=`*(obj : USkinnedMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bComponentUseFixedSkelBounds")
setValueInBoolProp(prop, obj, value)
proc `set bComponentUseFixedSkelBounds`*(
obj : USkinnedMeshComponentPtr; val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bComponentUseFixedSkelBounds")
setValueInBoolProp(prop, obj, value)
proc `bConsiderAllBodiesForBounds`*(obj : USkinnedMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bConsiderAllBodiesForBounds")
getValueFromBoolProp(prop, obj)
proc `bConsiderAllBodiesForBounds=`*(obj : USkinnedMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bConsiderAllBodiesForBounds")
setValueInBoolProp(prop, obj, value)
proc `set bConsiderAllBodiesForBounds`*(obj : USkinnedMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bConsiderAllBodiesForBounds")
setValueInBoolProp(prop, obj, value)
proc `bSyncAttachParentLOD`*(obj : USkinnedMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bSyncAttachParentLOD")
getValueFromBoolProp(prop, obj)
proc `bSyncAttachParentLOD=`*(obj : USkinnedMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bSyncAttachParentLOD")
setValueInBoolProp(prop, obj, value)
proc `set bSyncAttachParentLOD`*(obj : USkinnedMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bSyncAttachParentLOD")
setValueInBoolProp(prop, obj, value)
proc `bCastCapsuleDirectShadow`*(obj : USkinnedMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bCastCapsuleDirectShadow")
getValueFromBoolProp(prop, obj)
proc `bCastCapsuleDirectShadow=`*(obj : USkinnedMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bCastCapsuleDirectShadow")
setValueInBoolProp(prop, obj, value)
proc `set bCastCapsuleDirectShadow`*(obj : USkinnedMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bCastCapsuleDirectShadow")
setValueInBoolProp(prop, obj, value)
proc `bCastCapsuleIndirectShadow`*(obj : USkinnedMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bCastCapsuleIndirectShadow")
getValueFromBoolProp(prop, obj)
proc `bCastCapsuleIndirectShadow=`*(obj : USkinnedMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bCastCapsuleIndirectShadow")
setValueInBoolProp(prop, obj, value)
proc `set bCastCapsuleIndirectShadow`*(obj : USkinnedMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bCastCapsuleIndirectShadow")
setValueInBoolProp(prop, obj, value)
proc `bEnableUpdateRateOptimizations`*(obj : USkinnedMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bEnableUpdateRateOptimizations")
getValueFromBoolProp(prop, obj)
proc `bEnableUpdateRateOptimizations=`*(obj : USkinnedMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bEnableUpdateRateOptimizations")
setValueInBoolProp(prop, obj, value)
proc `set bEnableUpdateRateOptimizations`*(
obj : USkinnedMeshComponentPtr; val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bEnableUpdateRateOptimizations")
setValueInBoolProp(prop, obj, value)
proc `bDisplayDebugUpdateRateOptimizations`*(
obj : USkinnedMeshComponentPtr): bool {.exportcpp.} =
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bDisplayDebugUpdateRateOptimizations")
getValueFromBoolProp(prop, obj)
proc `bDisplayDebugUpdateRateOptimizations=`*(
obj : USkinnedMeshComponentPtr; val : bool) =
var value : bool = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bDisplayDebugUpdateRateOptimizations")
setValueInBoolProp(prop, obj, value)
proc `set bDisplayDebugUpdateRateOptimizations`*(
obj : USkinnedMeshComponentPtr; val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bDisplayDebugUpdateRateOptimizations")
setValueInBoolProp(prop, obj, value)
proc `bRenderStatic`*(obj : USkinnedMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bRenderStatic")
getValueFromBoolProp(prop, obj)
proc `bRenderStatic=`*(obj : USkinnedMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bRenderStatic")
setValueInBoolProp(prop, obj, value)
proc `set bRenderStatic`*(obj : USkinnedMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bRenderStatic")
setValueInBoolProp(prop, obj, value)
proc `bIgnoreLeaderPoseComponentLOD`*(obj : USkinnedMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bIgnoreLeaderPoseComponentLOD")
getValueFromBoolProp(prop, obj)
proc `bIgnoreLeaderPoseComponentLOD=`*(obj : USkinnedMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bIgnoreLeaderPoseComponentLOD")
setValueInBoolProp(prop, obj, value)
proc `set bIgnoreLeaderPoseComponentLOD`*(
obj : USkinnedMeshComponentPtr; val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"bIgnoreLeaderPoseComponentLOD")
setValueInBoolProp(prop, obj, value)
proc `capsuleIndirectShadowMinVisibility`*(
obj : USkinnedMeshComponentPtr): float32 {.exportcpp.} =
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"CapsuleIndirectShadowMinVisibility")
getPropertyValuePtr[float32](prop, obj)[]
proc `capsuleIndirectShadowMinVisibility=`*(
obj : USkinnedMeshComponentPtr; val : float32) =
var value : float32 = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"CapsuleIndirectShadowMinVisibility")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set capsuleIndirectShadowMinVisibility`*(
obj : USkinnedMeshComponentPtr; val : float32) {.
exportcpp.} =
var value : float32 = val
let prop = getClassByName("SkinnedMeshComponent").getFPropertyByName(
"CapsuleIndirectShadowMinVisibility")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc unloadSkinWeightProfile*(self : USkinnedMeshComponentPtr;
inProfileName : FName): void {.
exportcpp: "$1_".} =
type
Params = object
inProfileName: FName
var param = Params(inProfileName: inProfileName)
let fnName {.used.} = n "UnloadSkinWeightProfile"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc unHideBoneByName*(self : USkinnedMeshComponentPtr;
boneName : FName): void {.exportcpp: "$1_".} =
type
Params = object
boneName: FName
var param = Params(boneName: boneName)
let fnName {.used.} = n "UnHideBoneByName"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc transformToBoneSpace*(self : USkinnedMeshComponentPtr;
boneName : FName;
inPosition : FVector;
inRotation : FRotator;
outPosition : var FVector;
outRotation : var FRotator): void {.
exportcpp: "$1_".} =
type
Params = object
boneName: FName
inPosition: FVector
inRotation: FRotator
outPosition: FVector
outRotation: FRotator
var param = Params(boneName: boneName, inPosition: inPosition,
inRotation: inRotation,
outPosition: outPosition,
outRotation: outRotation)
let fnName {.used.} = n "TransformToBoneSpace"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
outPosition = param.outPosition
outRotation = param.outRotation
proc transformFromBoneSpace*(self : USkinnedMeshComponentPtr;
boneName : FName;
inPosition : FVector;
inRotation : FRotator;
outPosition : var FVector;
outRotation : var FRotator): void {.
exportcpp: "$1_".} =
type
Params = object
boneName: FName
inPosition: FVector
inRotation: FRotator
outPosition: FVector
outRotation: FRotator
var param = Params(boneName: boneName, inPosition: inPosition,
inRotation: inRotation,
outPosition: outPosition,
outRotation: outRotation)
let fnName {.used.} = n "TransformFromBoneSpace"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
outPosition = param.outPosition
outRotation = param.outRotation
proc showMaterialSection*(self : USkinnedMeshComponentPtr;
materialID : int32;
sectionIndex : int32; bShow : bool;
lODIndex : int32): void {.exportcpp: "$1_".} =
type
Params = object
materialID: int32
sectionIndex: int32
bShow: bool
lODIndex: int32
var param = Params(materialID: materialID,
sectionIndex: sectionIndex, bShow: bShow,
lODIndex: lODIndex)
let fnName {.used.} = n "ShowMaterialSection"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc showAllMaterialSections*(self : USkinnedMeshComponentPtr;
lODIndex : int32): void {.
exportcpp: "$1_".} =
type
Params = object
lODIndex: int32
var param = Params(lODIndex: lODIndex)
let fnName {.used.} = n "ShowAllMaterialSections"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setVertexOffsetUsage*(self : USkinnedMeshComponentPtr;
lODIndex : int32; usage : int32): void {.
exportcpp: "$1_".} =
type
Params = object
lODIndex: int32
usage: int32
var param = Params(lODIndex: lODIndex, usage: usage)
let fnName {.used.} = n "SetVertexOffsetUsage"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setVertexColorOverride_LinearColor*(
self : USkinnedMeshComponentPtr; lODIndex : int32;
vertexColors : var TArray[FLinearColor]): void {.exportcpp: "$1_".} =
type
Params = object
lODIndex: int32
vertexColors: TArray[FLinearColor]
var param = Params(lODIndex: lODIndex, vertexColors: vertexColors)
let fnName {.used.} = n "SetVertexColorOverride_LinearColor"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
vertexColors = param.vertexColors
proc setSkinWeightProfile*(self : USkinnedMeshComponentPtr;
inProfileName : FName): bool {.
exportcpp: "$1_".} =
type
Params = object
inProfileName: FName
returnValue: bool
var param = Params(inProfileName: inProfileName)
let fnName {.used.} = n "SetSkinWeightProfile"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc setSkinWeightOverride*(self : USkinnedMeshComponentPtr;
lODIndex : int32; skinWeights : var TArray[
FSkelMeshSkinWeightInfo]): void {.exportcpp: "$1_".} =
type
Params = object
lODIndex: int32
skinWeights: TArray[FSkelMeshSkinWeightInfo]
var param = Params(lODIndex: lODIndex, skinWeights: skinWeights)
let fnName {.used.} = n "SetSkinWeightOverride"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
skinWeights = param.skinWeights
proc setSkinnedAssetAndUpdate*(self : USkinnedMeshComponentPtr;
newMesh : USkinnedAssetPtr;
bReinitPose : bool = true): void {.
exportcpp: "$1_".} =
type
Params = object
newMesh: USkinnedAssetPtr
bReinitPose: bool
var param = Params(newMesh: newMesh, bReinitPose: bReinitPose)
let fnName {.used.} = n "SetSkinnedAssetAndUpdate"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setRenderStatic*(self : USkinnedMeshComponentPtr;
bNewValue : bool): void {.exportcpp: "$1_".} =
type
Params = object
bNewValue: bool
var param = Params(bNewValue: bNewValue)
let fnName {.used.} = n "SetRenderStatic"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setPreSkinningOffsets*(self : USkinnedMeshComponentPtr;
lODIndex : int32;
offsets : TArray[FVector]): void {.
exportcpp: "$1_".} =
type
Params = object
lODIndex: int32
offsets: TArray[FVector]
var param = Params(lODIndex: lODIndex, offsets: offsets)
let fnName {.used.} = n "SetPreSkinningOffsets"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setPostSkinningOffsets*(self : USkinnedMeshComponentPtr;
lODIndex : int32;
offsets : TArray[FVector]): void {.
exportcpp: "$1_".} =
type
Params = object
lODIndex: int32
offsets: TArray[FVector]
var param = Params(lODIndex: lODIndex, offsets: offsets)
let fnName {.used.} = n "SetPostSkinningOffsets"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setPhysicsAsset*(self : USkinnedMeshComponentPtr;
newPhysicsAsset : UPhysicsAssetPtr;
bForceReInit : bool = false): void {.
exportcpp: "$1_".} =
type
Params = object
newPhysicsAsset: UPhysicsAssetPtr
bForceReInit: bool
var param = Params(newPhysicsAsset: newPhysicsAsset,
bForceReInit: bForceReInit)
let fnName {.used.} = n "SetPhysicsAsset"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setMinLOD*(self : USkinnedMeshComponentPtr;
inNewMinLOD : int32): void {.exportcpp: "$1_".} =
type
Params = object
inNewMinLOD: int32
var param = Params(inNewMinLOD: inNewMinLOD)
let fnName {.used.} = n "SetMinLOD"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setMeshDeformer*(self : USkinnedMeshComponentPtr;
inMeshDeformer : UMeshDeformerPtr): void {.
exportcpp: "$1_".} =
type
Params = object
inMeshDeformer: UMeshDeformerPtr
var param = Params(inMeshDeformer: inMeshDeformer)
let fnName {.used.} = n "SetMeshDeformer"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setLeaderPoseComponent*(self : USkinnedMeshComponentPtr;
newLeaderBoneComponent : USkinnedMeshComponentPtr;
bForceUpdate : bool = false;
bInFollowerShouldTickPose : bool = false): void {.
exportcpp: "$1_".} =
type
Params = object
newLeaderBoneComponent: USkinnedMeshComponentPtr
bForceUpdate: bool
bInFollowerShouldTickPose: bool
var param = Params(newLeaderBoneComponent: newLeaderBoneComponent,
bForceUpdate: bForceUpdate, bInFollowerShouldTickPose: bInFollowerShouldTickPose)
let fnName {.used.} = n "SetLeaderPoseComponent"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setForcedLOD*(self : USkinnedMeshComponentPtr;
inNewForcedLOD : int32): void {.exportcpp: "$1_".} =
type
Params = object
inNewForcedLOD: int32
var param = Params(inNewForcedLOD: inNewForcedLOD)
let fnName {.used.} = n "SetForcedLOD"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setCastCapsuleIndirectShadow*(self : USkinnedMeshComponentPtr;
bNewValue : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bNewValue: bool
var param = Params(bNewValue: bNewValue)
let fnName {.used.} = n "SetCastCapsuleIndirectShadow"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setCastCapsuleDirectShadow*(self : USkinnedMeshComponentPtr;
bNewValue : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bNewValue: bool
var param = Params(bNewValue: bNewValue)
let fnName {.used.} = n "SetCastCapsuleDirectShadow"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setCapsuleIndirectShadowMinVisibility*(
self : USkinnedMeshComponentPtr; newValue : float32): void {.
exportcpp: "$1_".} =
type
Params = object
newValue: float32
var param = Params(newValue: newValue)
let fnName {.used.} = n "SetCapsuleIndirectShadowMinVisibility"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc isUsingSkinWeightProfile*(self : USkinnedMeshComponentPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsUsingSkinWeightProfile"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isMaterialSectionShown*(self : USkinnedMeshComponentPtr;
materialID : int32;
lODIndex : int32): bool {.
exportcpp: "$1_".} =
type
Params = object
materialID: int32
lODIndex: int32
returnValue: bool
var param = Params(materialID: materialID, lODIndex: lODIndex)
let fnName {.used.} = n "IsMaterialSectionShown"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isBoneHiddenByName*(self : USkinnedMeshComponentPtr;
boneName : FName): bool {.exportcpp: "$1_".} =
type
Params = object
boneName: FName
returnValue: bool
var param = Params(boneName: boneName)
let fnName {.used.} = n "IsBoneHiddenByName"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc hideBoneByName*(self : USkinnedMeshComponentPtr;
boneName : FName;
physBodyOption : EPhysBodyOp): void {.
exportcpp: "$1_".} =
type
Params = object
boneName: FName
physBodyOption: EPhysBodyOp
var param = Params(boneName: boneName,
physBodyOption: physBodyOption)
let fnName {.used.} = n "HideBoneByName"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc getVertexOffsetUsage*(self : USkinnedMeshComponentPtr;
lODIndex : int32): int32 {.exportcpp: "$1_".} =
type
Params = object
lODIndex: int32
returnValue: int32
var param = Params(lODIndex: lODIndex)
let fnName {.used.} = n "GetVertexOffsetUsage"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getTwistAndSwingAngleOfDeltaRotationFromRefPose*(
self : USkinnedMeshComponentPtr; boneName : FName;
outTwistAngle : var float32; outSwingAngle : var float32): bool {.
exportcpp: "$1_".} =
type
Params = object
boneName: FName
outTwistAngle: float32
outSwingAngle: float32
returnValue: bool
var param = Params(boneName: boneName,
outTwistAngle: outTwistAngle,
outSwingAngle: outSwingAngle)
let fnName {.used.} = n "GetTwistAndSwingAngleOfDeltaRotationFromRefPose"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
outTwistAngle = param.outTwistAngle
outSwingAngle = param.outSwingAngle
return param.returnValue
proc getSocketBoneName*(self : USkinnedMeshComponentPtr;
inSocketName : FName): FName {.
exportcpp: "$1_".} =
type
Params = object
inSocketName: FName
returnValue: FName
var param = Params(inSocketName: inSocketName)
let fnName {.used.} = n "GetSocketBoneName"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getSkinnedAsset*(self : USkinnedMeshComponentPtr): USkinnedAssetPtr {.
exportcpp: "$1_".} =
type
Params = object
returnValue: USkinnedAssetPtr
var param = Params()
let fnName {.used.} = n "GetSkinnedAsset"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getSkeletalMesh_DEPRECATED*(self : USkinnedMeshComponentPtr): USkeletalMeshPtr {.
exportcpp: "$1_".} =
type
Params = object
returnValue: USkeletalMeshPtr
var param = Params()
let fnName {.used.} = n "GetSkeletalMesh_DEPRECATED"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getRefPoseTransform*(self : USkinnedMeshComponentPtr;
boneIndex : int32): FTransform {.
exportcpp: "$1_".} =
type
Params = object
boneIndex: int32
returnValue: FTransform
var param = Params(boneIndex: boneIndex)
let fnName {.used.} = n "GetRefPoseTransform"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getRefPosePosition*(self : USkinnedMeshComponentPtr;
boneIndex : int32): FVector {.
exportcpp: "$1_".} =
type
Params = object
boneIndex: int32
returnValue: FVector
var param = Params(boneIndex: boneIndex)
let fnName {.used.} = n "GetRefPosePosition"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getPredictedLODLevel*(self : USkinnedMeshComponentPtr): int32 {.
exportcpp: "$1_".} =
type
Params = object
returnValue: int32
var param = Params()
let fnName {.used.} = n "GetPredictedLODLevel"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getParentBone*(self : USkinnedMeshComponentPtr;
boneName : FName): FName {.exportcpp: "$1_".} =
type
Params = object
boneName: FName
returnValue: FName
var param = Params(boneName: boneName)
let fnName {.used.} = n "GetParentBone"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getNumLODs*(self : USkinnedMeshComponentPtr): int32 {.
exportcpp: "$1_".} =
type
Params = object
returnValue: int32
var param = Params()
let fnName {.used.} = n "GetNumLODs"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getNumBones*(self : USkinnedMeshComponentPtr): int32 {.
exportcpp: "$1_".} =
type
Params = object
returnValue: int32
var param = Params()
let fnName {.used.} = n "GetNumBones"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getForcedLOD*(self : USkinnedMeshComponentPtr): int32 {.
exportcpp: "$1_".} =
type
Params = object
returnValue: int32
var param = Params()
let fnName {.used.} = n "GetForcedLOD"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getDeltaTransformFromRefPose*(self : USkinnedMeshComponentPtr;
boneName : FName;
baseName : FName = makeFName("None")): FTransform {.
exportcpp: "$1_".} =
type
Params = object
boneName: FName
baseName: FName
returnValue: FTransform
var param = Params(boneName: boneName, baseName: baseName)
let fnName {.used.} = n "GetDeltaTransformFromRefPose"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getCurrentSkinWeightProfileName*(self : USkinnedMeshComponentPtr): FName {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FName
var param = Params()
let fnName {.used.} = n "GetCurrentSkinWeightProfileName"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getBoneName*(self : USkinnedMeshComponentPtr;
boneIndex : int32): FName {.exportcpp: "$1_".} =
type
Params = object
boneIndex: int32
returnValue: FName
var param = Params(boneIndex: boneIndex)
let fnName {.used.} = n "GetBoneName"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getBoneIndex*(self : USkinnedMeshComponentPtr;
boneName : FName): int32 {.exportcpp: "$1_".} =
type
Params = object
boneName: FName
returnValue: int32
var param = Params(boneName: boneName)
let fnName {.used.} = n "GetBoneIndex"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc findClosestBone_K2*(self : USkinnedMeshComponentPtr;
testLocation : FVector;
boneLocation : var FVector;
ignoreScale : float32 = 0.0'f32;
bRequirePhysicsAsset : bool = false): FName {.
exportcpp: "$1_".} =
type
Params = object
testLocation: FVector
boneLocation: FVector
ignoreScale: float32
bRequirePhysicsAsset: bool
returnValue: FName
var param = Params(testLocation: testLocation,
boneLocation: boneLocation,
ignoreScale: ignoreScale,
bRequirePhysicsAsset: bRequirePhysicsAsset)
let fnName {.used.} = n "FindClosestBone_K2"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
boneLocation = param.boneLocation
return param.returnValue
proc clearVertexColorOverride*(self : USkinnedMeshComponentPtr;
lODIndex : int32): void {.
exportcpp: "$1_".} =
type
Params = object
lODIndex: int32
var param = Params(lODIndex: lODIndex)
let fnName {.used.} = n "ClearVertexColorOverride"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc clearSkinWeightProfile*(self : USkinnedMeshComponentPtr): void {.
exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "ClearSkinWeightProfile"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc clearSkinWeightOverride*(self : USkinnedMeshComponentPtr;
lODIndex : int32): void {.
exportcpp: "$1_".} =
type
Params = object
lODIndex: int32
var param = Params(lODIndex: lODIndex)
let fnName {.used.} = n "ClearSkinWeightOverride"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc boneIsChildOf*(self : USkinnedMeshComponentPtr;
boneName : FName; parentBoneName : FName): bool {.
exportcpp: "$1_".} =
type
Params = object
boneName: FName
parentBoneName: FName
returnValue: bool
var param = Params(boneName: boneName,
parentBoneName: parentBoneName)
let fnName {.used.} = n "BoneIsChildOf"
let fn {.used.} = getClassByName("SkinnedMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc keepUSkinnedMeshComponent(fake : USkinnedMeshComponent) {.
exportcpp.} =
discard
converter USkinnedMeshComponenttoULODSyncInterface*(
self : USkinnedMeshComponentPtr): ULODSyncInterfacePtr =
cast[ULODSyncInterfacePtr](self)
proc `skeletalMeshAsset`*(obj : USkeletalMeshComponentPtr): USkeletalMeshPtr {.
exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"SkeletalMeshAsset")
getPropertyValuePtr[USkeletalMeshPtr](prop, obj)[]
proc `skeletalMeshAsset=`*(obj : USkeletalMeshComponentPtr;
val : USkeletalMeshPtr) =
var value : USkeletalMeshPtr = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"SkeletalMeshAsset")
setPropertyValuePtr[USkeletalMeshPtr](prop, obj, value.addr)
proc `set skeletalMeshAsset`*(obj : USkeletalMeshComponentPtr;
val : USkeletalMeshPtr) {.exportcpp.} =
var value : USkeletalMeshPtr = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"SkeletalMeshAsset")
setPropertyValuePtr[USkeletalMeshPtr](prop, obj, value.addr)
proc `animClass`*(obj : USkeletalMeshComponentPtr): TSubclassOf[
UAnimInstance] {.exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"AnimClass")
getPropertyValuePtr[TSubclassOf[UAnimInstance]](prop, obj)[]
proc `animClass=`*(obj : USkeletalMeshComponentPtr;
val : TSubclassOf[UAnimInstance]) =
var value : TSubclassOf[UAnimInstance] = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"AnimClass")
setPropertyValuePtr[TSubclassOf[UAnimInstance]](prop, obj, value.addr)
proc `set animClass`*(obj : USkeletalMeshComponentPtr;
val : TSubclassOf[UAnimInstance]) {.exportcpp.} =
var value : TSubclassOf[UAnimInstance] = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"AnimClass")
setPropertyValuePtr[TSubclassOf[UAnimInstance]](prop, obj, value.addr)
proc `animationData`*(obj : USkeletalMeshComponentPtr): var FSingleAnimationPlayData {.
exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"AnimationData")
getPropertyValuePtr[FSingleAnimationPlayData](prop, obj)[]
proc `animationData=`*(obj : USkeletalMeshComponentPtr;
val : FSingleAnimationPlayData) =
var value : FSingleAnimationPlayData = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"AnimationData")
setPropertyValuePtr[FSingleAnimationPlayData](prop, obj, value.addr)
proc `set animationData`*(obj : USkeletalMeshComponentPtr;
val : FSingleAnimationPlayData) {.exportcpp.} =
var value : FSingleAnimationPlayData = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"AnimationData")
setPropertyValuePtr[FSingleAnimationPlayData](prop, obj, value.addr)
proc `globalAnimRateScale`*(obj : USkeletalMeshComponentPtr): float32 {.
exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"GlobalAnimRateScale")
getPropertyValuePtr[float32](prop, obj)[]
proc `globalAnimRateScale=`*(obj : USkeletalMeshComponentPtr;
val : float32) =
var value : float32 = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"GlobalAnimRateScale")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set globalAnimRateScale`*(obj : USkeletalMeshComponentPtr;
val : float32) {.exportcpp.} =
var value : float32 = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"GlobalAnimRateScale")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `kinematicBonesUpdateType`*(obj : USkeletalMeshComponentPtr): EKinematicBonesUpdateToPhysics {.
exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"KinematicBonesUpdateType")
getPropertyValuePtr[EKinematicBonesUpdateToPhysics](prop, obj)[]
proc `kinematicBonesUpdateType=`*(obj : USkeletalMeshComponentPtr;
val : EKinematicBonesUpdateToPhysics) =
var value : EKinematicBonesUpdateToPhysics = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"KinematicBonesUpdateType")
setPropertyValuePtr[EKinematicBonesUpdateToPhysics](prop, obj,
value.addr)
proc `set kinematicBonesUpdateType`*(obj : USkeletalMeshComponentPtr;
val : EKinematicBonesUpdateToPhysics) {.exportcpp.} =
var value : EKinematicBonesUpdateToPhysics = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"KinematicBonesUpdateType")
setPropertyValuePtr[EKinematicBonesUpdateToPhysics](prop, obj,
value.addr)
proc `physicsTransformUpdateMode`*(obj : USkeletalMeshComponentPtr): EPhysicsTransformUpdateMode {.
exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"PhysicsTransformUpdateMode")
getPropertyValuePtr[EPhysicsTransformUpdateMode](prop, obj)[]
proc `physicsTransformUpdateMode=`*(obj : USkeletalMeshComponentPtr;
val : EPhysicsTransformUpdateMode) =
var value : EPhysicsTransformUpdateMode = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"PhysicsTransformUpdateMode")
setPropertyValuePtr[EPhysicsTransformUpdateMode](prop, obj, value.addr)
proc `set physicsTransformUpdateMode`*(obj : USkeletalMeshComponentPtr;
val : EPhysicsTransformUpdateMode) {.exportcpp.} =
var value : EPhysicsTransformUpdateMode = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"PhysicsTransformUpdateMode")
setPropertyValuePtr[EPhysicsTransformUpdateMode](prop, obj, value.addr)
proc `animationMode`*(obj : USkeletalMeshComponentPtr): EAnimationMode {.
exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"AnimationMode")
getPropertyValuePtr[EAnimationMode](prop, obj)[]
proc `animationMode=`*(obj : USkeletalMeshComponentPtr;
val : EAnimationMode) =
var value : EAnimationMode = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"AnimationMode")
setPropertyValuePtr[EAnimationMode](prop, obj, value.addr)
proc `set animationMode`*(obj : USkeletalMeshComponentPtr;
val : EAnimationMode) {.exportcpp.} =
var value : EAnimationMode = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"AnimationMode")
setPropertyValuePtr[EAnimationMode](prop, obj, value.addr)
proc `bDisablePostProcessBlueprint`*(obj : USkeletalMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bDisablePostProcessBlueprint")
getValueFromBoolProp(prop, obj)
proc `bDisablePostProcessBlueprint=`*(obj : USkeletalMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bDisablePostProcessBlueprint")
setValueInBoolProp(prop, obj, value)
proc `set bDisablePostProcessBlueprint`*(
obj : USkeletalMeshComponentPtr; val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bDisablePostProcessBlueprint")
setValueInBoolProp(prop, obj, value)
proc `bEnablePhysicsOnDedicatedServer`*(obj : USkeletalMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bEnablePhysicsOnDedicatedServer")
getValueFromBoolProp(prop, obj)
proc `bEnablePhysicsOnDedicatedServer=`*(
obj : USkeletalMeshComponentPtr; val : bool) =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bEnablePhysicsOnDedicatedServer")
setValueInBoolProp(prop, obj, value)
proc `set bEnablePhysicsOnDedicatedServer`*(
obj : USkeletalMeshComponentPtr; val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bEnablePhysicsOnDedicatedServer")
setValueInBoolProp(prop, obj, value)
proc `bUpdateMeshWhenKinematic`*(obj : USkeletalMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bUpdateMeshWhenKinematic")
getValueFromBoolProp(prop, obj)
proc `bUpdateMeshWhenKinematic=`*(obj : USkeletalMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bUpdateMeshWhenKinematic")
setValueInBoolProp(prop, obj, value)
proc `set bUpdateMeshWhenKinematic`*(obj : USkeletalMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bUpdateMeshWhenKinematic")
setValueInBoolProp(prop, obj, value)
proc `bUpdateJointsFromAnimation`*(obj : USkeletalMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bUpdateJointsFromAnimation")
getValueFromBoolProp(prop, obj)
proc `bUpdateJointsFromAnimation=`*(obj : USkeletalMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bUpdateJointsFromAnimation")
setValueInBoolProp(prop, obj, value)
proc `set bUpdateJointsFromAnimation`*(obj : USkeletalMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bUpdateJointsFromAnimation")
setValueInBoolProp(prop, obj, value)
proc `bAllowClothActors`*(obj : USkeletalMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bAllowClothActors")
getValueFromBoolProp(prop, obj)
proc `bAllowClothActors=`*(obj : USkeletalMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bAllowClothActors")
setValueInBoolProp(prop, obj, value)
proc `set bAllowClothActors`*(obj : USkeletalMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bAllowClothActors")
setValueInBoolProp(prop, obj, value)
proc `bDisableClothSimulation`*(obj : USkeletalMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bDisableClothSimulation")
getValueFromBoolProp(prop, obj)
proc `bDisableClothSimulation=`*(obj : USkeletalMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bDisableClothSimulation")
setValueInBoolProp(prop, obj, value)
proc `set bDisableClothSimulation`*(obj : USkeletalMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bDisableClothSimulation")
setValueInBoolProp(prop, obj, value)
proc `bCollideWithEnvironment`*(obj : USkeletalMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bCollideWithEnvironment")
getValueFromBoolProp(prop, obj)
proc `bCollideWithEnvironment=`*(obj : USkeletalMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bCollideWithEnvironment")
setValueInBoolProp(prop, obj, value)
proc `set bCollideWithEnvironment`*(obj : USkeletalMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bCollideWithEnvironment")
setValueInBoolProp(prop, obj, value)
proc `bCollideWithAttachedChildren`*(obj : USkeletalMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bCollideWithAttachedChildren")
getValueFromBoolProp(prop, obj)
proc `bCollideWithAttachedChildren=`*(obj : USkeletalMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bCollideWithAttachedChildren")
setValueInBoolProp(prop, obj, value)
proc `set bCollideWithAttachedChildren`*(
obj : USkeletalMeshComponentPtr; val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bCollideWithAttachedChildren")
setValueInBoolProp(prop, obj, value)
proc `bForceCollisionUpdate`*(obj : USkeletalMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bForceCollisionUpdate")
getValueFromBoolProp(prop, obj)
proc `bForceCollisionUpdate=`*(obj : USkeletalMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bForceCollisionUpdate")
setValueInBoolProp(prop, obj, value)
proc `set bForceCollisionUpdate`*(obj : USkeletalMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bForceCollisionUpdate")
setValueInBoolProp(prop, obj, value)
proc `bLocalSpaceSimulation`*(obj : USkeletalMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bLocalSpaceSimulation")
getValueFromBoolProp(prop, obj)
proc `bLocalSpaceSimulation=`*(obj : USkeletalMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bLocalSpaceSimulation")
setValueInBoolProp(prop, obj, value)
proc `set bLocalSpaceSimulation`*(obj : USkeletalMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bLocalSpaceSimulation")
setValueInBoolProp(prop, obj, value)
proc `bResetAfterTeleport`*(obj : USkeletalMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bResetAfterTeleport")
getValueFromBoolProp(prop, obj)
proc `bResetAfterTeleport=`*(obj : USkeletalMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bResetAfterTeleport")
setValueInBoolProp(prop, obj, value)
proc `set bResetAfterTeleport`*(obj : USkeletalMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bResetAfterTeleport")
setValueInBoolProp(prop, obj, value)
proc `bDeferKinematicBoneUpdate`*(obj : USkeletalMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bDeferKinematicBoneUpdate")
getValueFromBoolProp(prop, obj)
proc `bDeferKinematicBoneUpdate=`*(obj : USkeletalMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bDeferKinematicBoneUpdate")
setValueInBoolProp(prop, obj, value)
proc `set bDeferKinematicBoneUpdate`*(obj : USkeletalMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bDeferKinematicBoneUpdate")
setValueInBoolProp(prop, obj, value)
proc `bNoSkeletonUpdate`*(obj : USkeletalMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bNoSkeletonUpdate")
getValueFromBoolProp(prop, obj)
proc `bNoSkeletonUpdate=`*(obj : USkeletalMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bNoSkeletonUpdate")
setValueInBoolProp(prop, obj, value)
proc `set bNoSkeletonUpdate`*(obj : USkeletalMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bNoSkeletonUpdate")
setValueInBoolProp(prop, obj, value)
proc `bPauseAnims`*(obj : USkeletalMeshComponentPtr): bool {.exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bPauseAnims")
getValueFromBoolProp(prop, obj)
proc `bPauseAnims=`*(obj : USkeletalMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bPauseAnims")
setValueInBoolProp(prop, obj, value)
proc `set bPauseAnims`*(obj : USkeletalMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bPauseAnims")
setValueInBoolProp(prop, obj, value)
proc `bEnablePerPolyCollision`*(obj : USkeletalMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bEnablePerPolyCollision")
getValueFromBoolProp(prop, obj)
proc `bEnablePerPolyCollision=`*(obj : USkeletalMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bEnablePerPolyCollision")
setValueInBoolProp(prop, obj, value)
proc `set bEnablePerPolyCollision`*(obj : USkeletalMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bEnablePerPolyCollision")
setValueInBoolProp(prop, obj, value)
proc `bIncludeComponentLocationIntoBounds`*(
obj : USkeletalMeshComponentPtr): bool {.exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bIncludeComponentLocationIntoBounds")
getValueFromBoolProp(prop, obj)
proc `bIncludeComponentLocationIntoBounds=`*(
obj : USkeletalMeshComponentPtr; val : bool) =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bIncludeComponentLocationIntoBounds")
setValueInBoolProp(prop, obj, value)
proc `set bIncludeComponentLocationIntoBounds`*(
obj : USkeletalMeshComponentPtr; val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bIncludeComponentLocationIntoBounds")
setValueInBoolProp(prop, obj, value)
proc `bPropagateCurvesToFollowers`*(obj : USkeletalMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bPropagateCurvesToFollowers")
getValueFromBoolProp(prop, obj)
proc `bPropagateCurvesToFollowers=`*(obj : USkeletalMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bPropagateCurvesToFollowers")
setValueInBoolProp(prop, obj, value)
proc `set bPropagateCurvesToFollowers`*(obj : USkeletalMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bPropagateCurvesToFollowers")
setValueInBoolProp(prop, obj, value)
proc `bSkipKinematicUpdateWhenInterpolating`*(
obj : USkeletalMeshComponentPtr): bool {.exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bSkipKinematicUpdateWhenInterpolating")
getValueFromBoolProp(prop, obj)
proc `bSkipKinematicUpdateWhenInterpolating=`*(
obj : USkeletalMeshComponentPtr; val : bool) =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bSkipKinematicUpdateWhenInterpolating")
setValueInBoolProp(prop, obj, value)
proc `set bSkipKinematicUpdateWhenInterpolating`*(
obj : USkeletalMeshComponentPtr; val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bSkipKinematicUpdateWhenInterpolating")
setValueInBoolProp(prop, obj, value)
proc `bSkipBoundsUpdateWhenInterpolating`*(
obj : USkeletalMeshComponentPtr): bool {.exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bSkipBoundsUpdateWhenInterpolating")
getValueFromBoolProp(prop, obj)
proc `bSkipBoundsUpdateWhenInterpolating=`*(
obj : USkeletalMeshComponentPtr; val : bool) =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bSkipBoundsUpdateWhenInterpolating")
setValueInBoolProp(prop, obj, value)
proc `set bSkipBoundsUpdateWhenInterpolating`*(
obj : USkeletalMeshComponentPtr; val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bSkipBoundsUpdateWhenInterpolating")
setValueInBoolProp(prop, obj, value)
proc `clothBlendWeight`*(obj : USkeletalMeshComponentPtr): float32 {.
exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"ClothBlendWeight")
getPropertyValuePtr[float32](prop, obj)[]
proc `clothBlendWeight=`*(obj : USkeletalMeshComponentPtr;
val : float32) =
var value : float32 = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"ClothBlendWeight")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set clothBlendWeight`*(obj : USkeletalMeshComponentPtr;
val : float32) {.exportcpp.} =
var value : float32 = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"ClothBlendWeight")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `bWaitForParallelClothTask`*(obj : USkeletalMeshComponentPtr): bool {.
exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bWaitForParallelClothTask")
getValueFromBoolProp(prop, obj)
proc `bWaitForParallelClothTask=`*(obj : USkeletalMeshComponentPtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bWaitForParallelClothTask")
setValueInBoolProp(prop, obj, value)
proc `set bWaitForParallelClothTask`*(obj : USkeletalMeshComponentPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"bWaitForParallelClothTask")
setValueInBoolProp(prop, obj, value)
proc `clothMaxDistanceScale`*(obj : USkeletalMeshComponentPtr): float32 {.
exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"ClothMaxDistanceScale")
getPropertyValuePtr[float32](prop, obj)[]
proc `clothMaxDistanceScale=`*(obj : USkeletalMeshComponentPtr;
val : float32) =
var value : float32 = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"ClothMaxDistanceScale")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set clothMaxDistanceScale`*(obj : USkeletalMeshComponentPtr;
val : float32) {.exportcpp.} =
var value : float32 = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"ClothMaxDistanceScale")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `teleportDistanceThreshold`*(obj : USkeletalMeshComponentPtr): float32 {.
exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"TeleportDistanceThreshold")
getPropertyValuePtr[float32](prop, obj)[]
proc `teleportDistanceThreshold=`*(obj : USkeletalMeshComponentPtr;
val : float32) =
var value : float32 = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"TeleportDistanceThreshold")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set teleportDistanceThreshold`*(obj : USkeletalMeshComponentPtr;
val : float32) {.exportcpp.} =
var value : float32 = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"TeleportDistanceThreshold")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `teleportRotationThreshold`*(obj : USkeletalMeshComponentPtr): float32 {.
exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"TeleportRotationThreshold")
getPropertyValuePtr[float32](prop, obj)[]
proc `teleportRotationThreshold=`*(obj : USkeletalMeshComponentPtr;
val : float32) =
var value : float32 = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"TeleportRotationThreshold")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `set teleportRotationThreshold`*(obj : USkeletalMeshComponentPtr;
val : float32) {.exportcpp.} =
var value : float32 = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"TeleportRotationThreshold")
setPropertyValuePtr[float32](prop, obj, value.addr)
proc `defaultAnimatingRigOverride`*(obj : USkeletalMeshComponentPtr): TSoftObjectPtr[
UObject] {.exportcpp.} =
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"DefaultAnimatingRigOverride")
getPropertyValuePtr[TSoftObjectPtr[UObject]](prop, obj)[]
proc `defaultAnimatingRigOverride=`*(obj : USkeletalMeshComponentPtr;
val : TSoftObjectPtr[UObject]) =
var value : TSoftObjectPtr[UObject] = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"DefaultAnimatingRigOverride")
setPropertyValuePtr[TSoftObjectPtr[UObject]](prop, obj, value.addr)
proc `set defaultAnimatingRigOverride`*(obj : USkeletalMeshComponentPtr;
val : TSoftObjectPtr[UObject]) {.
exportcpp.} =
var value : TSoftObjectPtr[UObject] = val
let prop = getClassByName("SkeletalMeshComponent").getFPropertyByName(
"DefaultAnimatingRigOverride")
setPropertyValuePtr[TSoftObjectPtr[UObject]](prop, obj, value.addr)
proc unlinkAnimClassLayers*(self : USkeletalMeshComponentPtr;
inClass : TSubclassOf[UAnimInstance]): void {.
exportcpp: "$1_".} =
type
Params = object
inClass: TSubclassOf[UAnimInstance]
var param = Params(inClass: inClass)
let fnName {.used.} = n "UnlinkAnimClassLayers"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc unbindClothFromLeaderPoseComponent*(
self : USkeletalMeshComponentPtr;
bRestoreSimulationSpace : bool = true): void {.exportcpp: "$1_".} =
type
Params = object
bRestoreSimulationSpace: bool
var param = Params(bRestoreSimulationSpace: bRestoreSimulationSpace)
let fnName {.used.} = n "UnbindClothFromLeaderPoseComponent"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc toggleDisablePostProcessBlueprint*(self : USkeletalMeshComponentPtr): void {.
exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "ToggleDisablePostProcessBlueprint"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc termBodiesBelow*(self : USkeletalMeshComponentPtr;
parentBoneName : FName): void {.exportcpp: "$1_".} =
type
Params = object
parentBoneName: FName
var param = Params(parentBoneName: parentBoneName)
let fnName {.used.} = n "TermBodiesBelow"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc suspendClothingSimulation*(self : USkeletalMeshComponentPtr): void {.
exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "SuspendClothingSimulation"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc stop*(self : USkeletalMeshComponentPtr): void {.exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "Stop"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc snapshotPose*(self : USkeletalMeshComponentPtr;
snapshot : var FPoseSnapshot): void {.
exportcpp: "$1_".} =
type
Params = object
snapshot: FPoseSnapshot
var param = Params(snapshot: snapshot)
let fnName {.used.} = n "SnapshotPose"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
snapshot = param.snapshot
proc setUpdateClothInEditor*(self : USkeletalMeshComponentPtr;
newUpdateState : bool): void {.
exportcpp: "$1_".} =
type
Params = object
newUpdateState: bool
var param = Params(newUpdateState: newUpdateState)
let fnName {.used.} = n "SetUpdateClothInEditor"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setUpdateAnimationInEditor*(self : USkeletalMeshComponentPtr;
newUpdateState : bool): void {.
exportcpp: "$1_".} =
type
Params = object
newUpdateState: bool
var param = Params(newUpdateState: newUpdateState)
let fnName {.used.} = n "SetUpdateAnimationInEditor"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setTeleportRotationThreshold*(self : USkeletalMeshComponentPtr;
threshold : float32): void {.
exportcpp: "$1_".} =
type
Params = object
threshold: float32
var param = Params(threshold: threshold)
let fnName {.used.} = n "SetTeleportRotationThreshold"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setTeleportDistanceThreshold*(self : USkeletalMeshComponentPtr;
threshold : float32): void {.
exportcpp: "$1_".} =
type
Params = object
threshold: float32
var param = Params(threshold: threshold)
let fnName {.used.} = n "SetTeleportDistanceThreshold"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setSkeletalMeshAsset*(self : USkeletalMeshComponentPtr;
newMesh : USkeletalMeshPtr): void {.
exportcpp: "$1_".} =
type
Params = object
newMesh: USkeletalMeshPtr
var param = Params(newMesh: newMesh)
let fnName {.used.} = n "SetSkeletalMeshAsset"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setPosition*(self : USkeletalMeshComponentPtr;
inPos : float32;
bFireNotifies : bool = true): void {.
exportcpp: "$1_".} =
type
Params = object
inPos: float32
bFireNotifies: bool
var param = Params(inPos: inPos, bFireNotifies: bFireNotifies)
let fnName {.used.} = n "SetPosition"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setPlayRate*(self : USkeletalMeshComponentPtr;
rate : float32): void {.exportcpp: "$1_".} =
type
Params = object
rate: float32
var param = Params(rate: rate)
let fnName {.used.} = n "SetPlayRate"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setPhysicsBlendWeight*(self : USkeletalMeshComponentPtr;
physicsBlendWeight : float32): void {.
exportcpp: "$1_".} =
type
Params = object
physicsBlendWeight: float32
var param = Params(physicsBlendWeight: physicsBlendWeight)
let fnName {.used.} = n "SetPhysicsBlendWeight"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setNotifyRigidBodyCollisionBelow*(self : USkeletalMeshComponentPtr;
bNewNotifyRigidBodyCollision : bool; boneName : FName = makeFName(
"None"); bIncludeSelf : bool = true): void {.exportcpp: "$1_".} =
type
Params = object
bNewNotifyRigidBodyCollision: bool
boneName: FName
bIncludeSelf: bool
var param = Params(bNewNotifyRigidBodyCollision: bNewNotifyRigidBodyCollision,
boneName: boneName, bIncludeSelf: bIncludeSelf)
let fnName {.used.} = n "SetNotifyRigidBodyCollisionBelow"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setMorphTarget*(self : USkeletalMeshComponentPtr;
morphTargetName : FName;
value : float32;
bRemoveZeroWeight : bool = true): void {.
exportcpp: "$1_".} =
type
Params = object
morphTargetName: FName
value: float32
bRemoveZeroWeight: bool
var param = Params(morphTargetName: morphTargetName, value: value,
bRemoveZeroWeight: bRemoveZeroWeight)
let fnName {.used.} = n "SetMorphTarget"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setEnablePhysicsBlending*(self : USkeletalMeshComponentPtr;
bNewBlendPhysics : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bNewBlendPhysics: bool
var param = Params(bNewBlendPhysics: bNewBlendPhysics)
let fnName {.used.} = n "SetEnablePhysicsBlending"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setEnableGravityOnAllBodiesBelow*(self : USkeletalMeshComponentPtr;
bEnableGravity : bool;
boneName : FName;
bIncludeSelf : bool = true): void {.
exportcpp: "$1_".} =
type
Params = object
bEnableGravity: bool
boneName: FName
bIncludeSelf: bool
var param = Params(bEnableGravity: bEnableGravity,
boneName: boneName, bIncludeSelf: bIncludeSelf)
let fnName {.used.} = n "SetEnableGravityOnAllBodiesBelow"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setEnableBodyGravity*(self : USkeletalMeshComponentPtr;
bEnableGravity : bool;
boneName : FName): void {.exportcpp: "$1_".} =
type
Params = object
bEnableGravity: bool
boneName: FName
var param = Params(bEnableGravity: bEnableGravity,
boneName: boneName)
let fnName {.used.} = n "SetEnableBodyGravity"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setDisablePostProcessBlueprint*(self : USkeletalMeshComponentPtr;
bInDisablePostProcess : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bInDisablePostProcess: bool
var param = Params(bInDisablePostProcess: bInDisablePostProcess)
let fnName {.used.} = n "SetDisablePostProcessBlueprint"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setDisableAnimCurves*(self : USkeletalMeshComponentPtr;
bInDisableAnimCurves : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bInDisableAnimCurves: bool
var param = Params(bInDisableAnimCurves: bInDisableAnimCurves)
let fnName {.used.} = n "SetDisableAnimCurves"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setDefaultAnimatingRigOverride*(self : USkeletalMeshComponentPtr;
inAnimatingRig : TSoftObjectPtr[UObject]): void {.exportcpp: "$1_".} =
type
Params = object
inAnimatingRig: TSoftObjectPtr[UObject]
var param = Params(inAnimatingRig: inAnimatingRig)
let fnName {.used.} = n "SetDefaultAnimatingRigOverride"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setConstraintProfileForAll*(self : USkeletalMeshComponentPtr;
profileName : FName;
bDefaultIfNotFound : bool = false): void {.
exportcpp: "$1_".} =
type
Params = object
profileName: FName
bDefaultIfNotFound: bool
var param = Params(profileName: profileName,
bDefaultIfNotFound: bDefaultIfNotFound)
let fnName {.used.} = n "SetConstraintProfileForAll"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setConstraintProfile*(self : USkeletalMeshComponentPtr;
jointName : FName;
profileName : FName;
bDefaultIfNotFound : bool = false): void {.
exportcpp: "$1_".} =
type
Params = object
jointName: FName
profileName: FName
bDefaultIfNotFound: bool
var param = Params(jointName: jointName, profileName: profileName,
bDefaultIfNotFound: bDefaultIfNotFound)
let fnName {.used.} = n "SetConstraintProfile"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setClothMaxDistanceScale*(self : USkeletalMeshComponentPtr;
scale : float32): void {.
exportcpp: "$1_".} =
type
Params = object
scale: float32
var param = Params(scale: scale)
let fnName {.used.} = n "SetClothMaxDistanceScale"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setBodyNotifyRigidBodyCollision*(self : USkeletalMeshComponentPtr;
bNewNotifyRigidBodyCollision : bool; boneName : FName = makeFName(
"None")): void {.exportcpp: "$1_".} =
type
Params = object
bNewNotifyRigidBodyCollision: bool
boneName: FName
var param = Params(bNewNotifyRigidBodyCollision: bNewNotifyRigidBodyCollision,
boneName: boneName)
let fnName {.used.} = n "SetBodyNotifyRigidBodyCollision"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setAnimClass*(self : USkeletalMeshComponentPtr;
newClass : UClassPtr): void {.exportcpp: "$1_".} =
type
Params = object
newClass: UClassPtr
var param = Params(newClass: newClass)
let fnName {.used.} = n "SetAnimClass"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setAnimationMode*(self : USkeletalMeshComponentPtr;
inAnimationMode : EAnimationMode): void {.
exportcpp: "$1_".} =
type
Params = object
inAnimationMode: EAnimationMode
var param = Params(inAnimationMode: inAnimationMode)
let fnName {.used.} = n "SetAnimationMode"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setAnimation*(self : USkeletalMeshComponentPtr;
newAnimToPlay : UAnimationAssetPtr): void {.
exportcpp: "$1_".} =
type
Params = object
newAnimToPlay: UAnimationAssetPtr
var param = Params(newAnimToPlay: newAnimToPlay)
let fnName {.used.} = n "SetAnimation"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setAngularLimits*(self : USkeletalMeshComponentPtr;
inBoneName : FName;
swing1LimitAngle : float32;
twistLimitAngle : float32;
swing2LimitAngle : float32): void {.
exportcpp: "$1_".} =
type
Params = object
inBoneName: FName
swing1LimitAngle: float32
twistLimitAngle: float32
swing2LimitAngle: float32
var param = Params(inBoneName: inBoneName,
swing1LimitAngle: swing1LimitAngle,
twistLimitAngle: twistLimitAngle,
swing2LimitAngle: swing2LimitAngle)
let fnName {.used.} = n "SetAngularLimits"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setAllowRigidBodyAnimNode*(self : USkeletalMeshComponentPtr;
bInAllow : bool;
bReinitAnim : bool = true): void {.
exportcpp: "$1_".} =
type
Params = object
bInAllow: bool
bReinitAnim: bool
var param = Params(bInAllow: bInAllow, bReinitAnim: bReinitAnim)
let fnName {.used.} = n "SetAllowRigidBodyAnimNode"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setAllowedAnimCurvesEvaluation*(self : USkeletalMeshComponentPtr;
list : var TArray[FName];
bAllow : bool): void {.
exportcpp: "$1_".} =
type
Params = object
list: TArray[FName]
bAllow: bool
var param = Params(list: list, bAllow: bAllow)
let fnName {.used.} = n "SetAllowedAnimCurvesEvaluation"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
list = param.list
proc setAllowClothActors*(self : USkeletalMeshComponentPtr;
bInAllow : bool): void {.exportcpp: "$1_".} =
type
Params = object
bInAllow: bool
var param = Params(bInAllow: bInAllow)
let fnName {.used.} = n "SetAllowClothActors"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setAllowAnimCurveEvaluation*(self : USkeletalMeshComponentPtr;
bInAllow : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bInAllow: bool
var param = Params(bInAllow: bInAllow)
let fnName {.used.} = n "SetAllowAnimCurveEvaluation"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setAllMotorsAngularVelocityDrive*(self : USkeletalMeshComponentPtr;
bEnableSwingDrive : bool;
bEnableTwistDrive : bool;
bSkipCustomPhysicsType : bool = false): void {.exportcpp: "$1_".} =
type
Params = object
bEnableSwingDrive: bool
bEnableTwistDrive: bool
bSkipCustomPhysicsType: bool
var param = Params(bEnableSwingDrive: bEnableSwingDrive,
bEnableTwistDrive: bEnableTwistDrive,
bSkipCustomPhysicsType: bSkipCustomPhysicsType)
let fnName {.used.} = n "SetAllMotorsAngularVelocityDrive"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setAllMotorsAngularPositionDrive*(self : USkeletalMeshComponentPtr;
bEnableSwingDrive : bool;
bEnableTwistDrive : bool;
bSkipCustomPhysicsType : bool = false): void {.exportcpp: "$1_".} =
type
Params = object
bEnableSwingDrive: bool
bEnableTwistDrive: bool
bSkipCustomPhysicsType: bool
var param = Params(bEnableSwingDrive: bEnableSwingDrive,
bEnableTwistDrive: bEnableTwistDrive,
bSkipCustomPhysicsType: bSkipCustomPhysicsType)
let fnName {.used.} = n "SetAllMotorsAngularPositionDrive"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setAllMotorsAngularDriveParams*(self : USkeletalMeshComponentPtr;
inSpring : float32;
inDamping : float32;
inForceLimit : float32;
bSkipCustomPhysicsType : bool = false): void {.exportcpp: "$1_".} =
type
Params = object
inSpring: float32
inDamping: float32
inForceLimit: float32
bSkipCustomPhysicsType: bool
var param = Params(inSpring: inSpring, inDamping: inDamping,
inForceLimit: inForceLimit,
bSkipCustomPhysicsType: bSkipCustomPhysicsType)
let fnName {.used.} = n "SetAllMotorsAngularDriveParams"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setAllBodiesSimulatePhysics*(self : USkeletalMeshComponentPtr;
bNewSimulate : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bNewSimulate: bool
var param = Params(bNewSimulate: bNewSimulate)
let fnName {.used.} = n "SetAllBodiesSimulatePhysics"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setAllBodiesPhysicsBlendWeight*(self : USkeletalMeshComponentPtr;
physicsBlendWeight : float32;
bSkipCustomPhysicsType : bool = false): void {.exportcpp: "$1_".} =
type
Params = object
physicsBlendWeight: float32
bSkipCustomPhysicsType: bool
var param = Params(physicsBlendWeight: physicsBlendWeight,
bSkipCustomPhysicsType: bSkipCustomPhysicsType)
let fnName {.used.} = n "SetAllBodiesPhysicsBlendWeight"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setAllBodiesBelowSimulatePhysics*(self : USkeletalMeshComponentPtr;
inBoneName : var FName;
bNewSimulate : bool;
bIncludeSelf : bool = true): void {.
exportcpp: "$1_".} =
type
Params = object
inBoneName: FName
bNewSimulate: bool
bIncludeSelf: bool
var param = Params(inBoneName: inBoneName,
bNewSimulate: bNewSimulate,
bIncludeSelf: bIncludeSelf)
let fnName {.used.} = n "SetAllBodiesBelowSimulatePhysics"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
inBoneName = param.inBoneName
proc setAllBodiesBelowPhysicsDisabled*(self : USkeletalMeshComponentPtr;
inBoneName : var FName;
bDisabled : bool;
bIncludeSelf : bool = true): void {.
exportcpp: "$1_".} =
type
Params = object
inBoneName: FName
bDisabled: bool
bIncludeSelf: bool
var param = Params(inBoneName: inBoneName, bDisabled: bDisabled,
bIncludeSelf: bIncludeSelf)
let fnName {.used.} = n "SetAllBodiesBelowPhysicsDisabled"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
inBoneName = param.inBoneName
proc setAllBodiesBelowPhysicsBlendWeight*(
self : USkeletalMeshComponentPtr; inBoneName : var FName;
physicsBlendWeight : float32;
bSkipCustomPhysicsType : bool = false;
bIncludeSelf : bool = true): void {.exportcpp: "$1_".} =
type
Params = object
inBoneName: FName
physicsBlendWeight: float32
bSkipCustomPhysicsType: bool
bIncludeSelf: bool
var param = Params(inBoneName: inBoneName,
physicsBlendWeight: physicsBlendWeight,
bSkipCustomPhysicsType: bSkipCustomPhysicsType,
bIncludeSelf: bIncludeSelf)
let fnName {.used.} = n "SetAllBodiesBelowPhysicsBlendWeight"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
inBoneName = param.inBoneName
proc setAllBodiesBelowLinearVelocity*(self : USkeletalMeshComponentPtr;
inBoneName : var FName;
linearVelocity : var FVector;
bIncludeSelf : bool = true): void {.
exportcpp: "$1_".} =
type
Params = object
inBoneName: FName
linearVelocity: FVector
bIncludeSelf: bool
var param = Params(inBoneName: inBoneName,
linearVelocity: linearVelocity,
bIncludeSelf: bIncludeSelf)
let fnName {.used.} = n "SetAllBodiesBelowLinearVelocity"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
inBoneName = param.inBoneName
linearVelocity = param.linearVelocity
proc resumeClothingSimulation*(self : USkeletalMeshComponentPtr): void {.
exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "ResumeClothingSimulation"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc resetClothTeleportMode*(self : USkeletalMeshComponentPtr): void {.
exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "ResetClothTeleportMode"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc resetAnimInstanceDynamics*(self : USkeletalMeshComponentPtr;
inTeleportType : ETeleportType = ETeleportType.ResetPhysics): void {.
exportcpp: "$1_".} =
type
Params = object
inTeleportType: ETeleportType
var param = Params(inTeleportType: inTeleportType)
let fnName {.used.} = n "ResetAnimInstanceDynamics"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc resetAllowedAnimCurveEvaluation*(self : USkeletalMeshComponentPtr): void {.
exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "ResetAllowedAnimCurveEvaluation"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc resetAllBodiesSimulatePhysics*(self : USkeletalMeshComponentPtr): void {.
exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "ResetAllBodiesSimulatePhysics"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc playAnimation*(self : USkeletalMeshComponentPtr;
newAnimToPlay : UAnimationAssetPtr;
bLooping : bool): void {.exportcpp: "$1_".} =
type
Params = object
newAnimToPlay: UAnimationAssetPtr
bLooping: bool
var param = Params(newAnimToPlay: newAnimToPlay, bLooping: bLooping)
let fnName {.used.} = n "PlayAnimation"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc play*(self : USkeletalMeshComponentPtr; bLooping : bool): void {.
exportcpp: "$1_".} =
type
Params = object
bLooping: bool
var param = Params(bLooping: bLooping)
let fnName {.used.} = n "Play"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc overrideAnimationData*(self : USkeletalMeshComponentPtr;
inAnimToPlay : UAnimationAssetPtr;
bIsLooping : bool = true;
bIsPlaying : bool = true;
position : float32 = 0.0'f32;
playRate : float32 = 1.0'f32): void {.
exportcpp: "$1_".} =
type
Params = object
inAnimToPlay: UAnimationAssetPtr
bIsLooping: bool
bIsPlaying: bool
position: float32
playRate: float32
var param = Params(inAnimToPlay: inAnimToPlay,
bIsLooping: bIsLooping, bIsPlaying: bIsPlaying,
position: position, playRate: playRate)
let fnName {.used.} = n "OverrideAnimationData"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc linkAnimGraphByTag*(self : USkeletalMeshComponentPtr;
inTag : FName;
inClass : TSubclassOf[UAnimInstance]): void {.
exportcpp: "$1_".} =
type
Params = object
inTag: FName
inClass: TSubclassOf[UAnimInstance]
var param = Params(inTag: inTag, inClass: inClass)
let fnName {.used.} = n "LinkAnimGraphByTag"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc linkAnimClassLayers*(self : USkeletalMeshComponentPtr;
inClass : TSubclassOf[UAnimInstance]): void {.
exportcpp: "$1_".} =
type
Params = object
inClass: TSubclassOf[UAnimInstance]
var param = Params(inClass: inClass)
let fnName {.used.} = n "LinkAnimClassLayers"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc getClosestPointOnPhysicsAsset*(self : USkeletalMeshComponentPtr;
worldPosition : var FVector;
closestWorldPosition : var FVector; normal : var FVector;
boneName : var FName;
distance : var float32): bool {.
exportcpp: "$1_".} =
type
Params = object
worldPosition: FVector
closestWorldPosition: FVector
normal: FVector
boneName: FName
distance: float32
returnValue: bool
var param = Params(worldPosition: worldPosition,
closestWorldPosition: closestWorldPosition,
normal: normal, boneName: boneName,
distance: distance)
let fnName {.used.} = n "K2_GetClosestPointOnPhysicsAsset"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
worldPosition = param.worldPosition
closestWorldPosition = param.closestWorldPosition
normal = param.normal
boneName = param.boneName
distance = param.distance
return param.returnValue
proc isPlaying*(self : USkeletalMeshComponentPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsPlaying"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isClothingSimulationSuspended*(self : USkeletalMeshComponentPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsClothingSimulationSuspended"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isBodyGravityEnabled*(self : USkeletalMeshComponentPtr;
boneName : FName): bool {.exportcpp: "$1_".} =
type
Params = object
boneName: FName
returnValue: bool
var param = Params(boneName: boneName)
let fnName {.used.} = n "IsBodyGravityEnabled"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc hasValidAnimationInstance*(self : USkeletalMeshComponentPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "HasValidAnimationInstance"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getTransformAttribute_Ref*(self : USkeletalMeshComponentPtr;
boneName : var FName;
attributeName : var FName;
outValue : var FTransform;
lookupType : ECustomBoneAttributeLookup = ECustomBoneAttributeLookup.BoneOnly): bool {.
exportcpp: "$1_".} =
type
Params = object
boneName: FName
attributeName: FName
outValue: FTransform
lookupType: ECustomBoneAttributeLookup
returnValue: bool
var param = Params(boneName: boneName,
attributeName: attributeName,
outValue: outValue, lookupType: lookupType)
let fnName {.used.} = n "GetTransformAttribute_Ref"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
boneName = param.boneName
attributeName = param.attributeName
outValue = param.outValue
return param.returnValue
proc getTransformAttribute*(self : USkeletalMeshComponentPtr;
boneName : var FName;
attributeName : var FName;
defaultValue : FTransform;
outValue : var FTransform;
lookupType : ECustomBoneAttributeLookup = ECustomBoneAttributeLookup.BoneOnly): bool {.
exportcpp: "$1_".} =
type
Params = object
boneName: FName
attributeName: FName
defaultValue: FTransform
outValue: FTransform
lookupType: ECustomBoneAttributeLookup
returnValue: bool
var param = Params(boneName: boneName,
attributeName: attributeName,
defaultValue: defaultValue, outValue: outValue,
lookupType: lookupType)
let fnName {.used.} = n "GetTransformAttribute"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
boneName = param.boneName
attributeName = param.attributeName
outValue = param.outValue
return param.returnValue
proc getTeleportRotationThreshold*(self : USkeletalMeshComponentPtr): float32 {.
exportcpp: "$1_".} =
type
Params = object
returnValue: float32
var param = Params()
let fnName {.used.} = n "GetTeleportRotationThreshold"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getTeleportDistanceThreshold*(self : USkeletalMeshComponentPtr): float32 {.
exportcpp: "$1_".} =
type
Params = object
returnValue: float32
var param = Params()
let fnName {.used.} = n "GetTeleportDistanceThreshold"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getStringAttribute_Ref*(self : USkeletalMeshComponentPtr;
boneName : var FName;
attributeName : var FName;
outValue : var FString;
lookupType : ECustomBoneAttributeLookup = ECustomBoneAttributeLookup.BoneOnly): bool {.
exportcpp: "$1_".} =
type
Params = object
boneName: FName
attributeName: FName
outValue: FString
lookupType: ECustomBoneAttributeLookup
returnValue: bool
var param = Params(boneName: boneName,
attributeName: attributeName,
outValue: outValue, lookupType: lookupType)
let fnName {.used.} = n "GetStringAttribute_Ref"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
boneName = param.boneName
attributeName = param.attributeName
outValue = param.outValue
return param.returnValue
proc getStringAttribute*(self : USkeletalMeshComponentPtr;
boneName : var FName;
attributeName : var FName;
defaultValue : FString;
outValue : var FString; lookupType : ECustomBoneAttributeLookup = ECustomBoneAttributeLookup.BoneOnly): bool {.
exportcpp: "$1_".} =
type
Params = object
boneName: FName
attributeName: FName
defaultValue: FString
outValue: FString
lookupType: ECustomBoneAttributeLookup
returnValue: bool
var param = Params(boneName: boneName,
attributeName: attributeName,
defaultValue: defaultValue, outValue: outValue,
lookupType: lookupType)
let fnName {.used.} = n "GetStringAttribute"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
boneName = param.boneName
attributeName = param.attributeName
outValue = param.outValue
return param.returnValue
proc getSkeletalMeshAsset*(self : USkeletalMeshComponentPtr): USkeletalMeshPtr {.
exportcpp: "$1_".} =
type
Params = object
returnValue: USkeletalMeshPtr
var param = Params()
let fnName {.used.} = n "GetSkeletalMeshAsset"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getSkeletalCenterOfMass*(self : USkeletalMeshComponentPtr): FVector {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FVector
var param = Params()
let fnName {.used.} = n "GetSkeletalCenterOfMass"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getPostProcessInstance*(self : USkeletalMeshComponentPtr): UAnimInstancePtr {.
exportcpp: "$1_".} =
type
Params = object
returnValue: UAnimInstancePtr
var param = Params()
let fnName {.used.} = n "GetPostProcessInstance"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getPosition*(self : USkeletalMeshComponentPtr): float32 {.
exportcpp: "$1_".} =
type
Params = object
returnValue: float32
var param = Params()
let fnName {.used.} = n "GetPosition"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getPlayRate*(self : USkeletalMeshComponentPtr): float32 {.
exportcpp: "$1_".} =
type
Params = object
returnValue: float32
var param = Params()
let fnName {.used.} = n "GetPlayRate"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getMorphTarget*(self : USkeletalMeshComponentPtr;
morphTargetName : FName): float32 {.
exportcpp: "$1_".} =
type
Params = object
morphTargetName: FName
returnValue: float32
var param = Params(morphTargetName: morphTargetName)
let fnName {.used.} = n "GetMorphTarget"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getLinkedAnimLayerInstanceByGroup*(self : USkeletalMeshComponentPtr;
inGroup : FName): UAnimInstancePtr {.
exportcpp: "$1_".} =
type
Params = object
inGroup: FName
returnValue: UAnimInstancePtr
var param = Params(inGroup: inGroup)
let fnName {.used.} = n "GetLinkedAnimLayerInstanceByGroup"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getLinkedAnimLayerInstanceByClass*(self : USkeletalMeshComponentPtr;
inClass : TSubclassOf[UAnimInstance]): UAnimInstancePtr {.
exportcpp: "$1_".} =
type
Params = object
inClass: TSubclassOf[UAnimInstance]
returnValue: UAnimInstancePtr
var param = Params(inClass: inClass)
let fnName {.used.} = n "GetLinkedAnimLayerInstanceByClass"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getLinkedAnimGraphInstancesByTag*(self : USkeletalMeshComponentPtr;
inTag : FName;
outLinkedInstances : var TArray[UAnimInstancePtr]): void {.
exportcpp: "$1_".} =
type
Params = object
inTag: FName
outLinkedInstances: TArray[UAnimInstancePtr]
var param = Params(inTag: inTag,
outLinkedInstances: outLinkedInstances)
let fnName {.used.} = n "GetLinkedAnimGraphInstancesByTag"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
outLinkedInstances = param.outLinkedInstances
proc getLinkedAnimGraphInstanceByTag*(self : USkeletalMeshComponentPtr;
inTag : FName): UAnimInstancePtr {.
exportcpp: "$1_".} =
type
Params = object
inTag: FName
returnValue: UAnimInstancePtr
var param = Params(inTag: inTag)
let fnName {.used.} = n "GetLinkedAnimGraphInstanceByTag"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getIntegerAttribute_Ref*(self : USkeletalMeshComponentPtr;
boneName : var FName;
attributeName : var FName;
outValue : var int32;
lookupType : ECustomBoneAttributeLookup = ECustomBoneAttributeLookup.BoneOnly): bool {.
exportcpp: "$1_".} =
type
Params = object
boneName: FName
attributeName: FName
outValue: int32
lookupType: ECustomBoneAttributeLookup
returnValue: bool
var param = Params(boneName: boneName,
attributeName: attributeName,
outValue: outValue, lookupType: lookupType)
let fnName {.used.} = n "GetIntegerAttribute_Ref"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
boneName = param.boneName
attributeName = param.attributeName
outValue = param.outValue
return param.returnValue
proc getIntegerAttribute*(self : USkeletalMeshComponentPtr;
boneName : var FName;
attributeName : var FName;
defaultValue : int32;
outValue : var int32; lookupType : ECustomBoneAttributeLookup = ECustomBoneAttributeLookup.BoneOnly): bool {.
exportcpp: "$1_".} =
type
Params = object
boneName: FName
attributeName: FName
defaultValue: int32
outValue: int32
lookupType: ECustomBoneAttributeLookup
returnValue: bool
var param = Params(boneName: boneName,
attributeName: attributeName,
defaultValue: defaultValue, outValue: outValue,
lookupType: lookupType)
let fnName {.used.} = n "GetIntegerAttribute"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
boneName = param.boneName
attributeName = param.attributeName
outValue = param.outValue
return param.returnValue
proc getFloatAttribute_Ref*(self : USkeletalMeshComponentPtr;
boneName : var FName;
attributeName : var FName;
outValue : var float32;
lookupType : ECustomBoneAttributeLookup = ECustomBoneAttributeLookup.BoneOnly): bool {.
exportcpp: "$1_".} =
type
Params = object
boneName: FName
attributeName: FName
outValue: float32
lookupType: ECustomBoneAttributeLookup
returnValue: bool
var param = Params(boneName: boneName,
attributeName: attributeName,
outValue: outValue, lookupType: lookupType)
let fnName {.used.} = n "GetFloatAttribute_Ref"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
boneName = param.boneName
attributeName = param.attributeName
outValue = param.outValue
return param.returnValue
proc getFloatAttribute*(self : USkeletalMeshComponentPtr;
boneName : var FName;
attributeName : var FName;
defaultValue : float32;
outValue : var float32; lookupType : ECustomBoneAttributeLookup = ECustomBoneAttributeLookup.BoneOnly): bool {.
exportcpp: "$1_".} =
type
Params = object
boneName: FName
attributeName: FName
defaultValue: float32
outValue: float32
lookupType: ECustomBoneAttributeLookup
returnValue: bool
var param = Params(boneName: boneName,
attributeName: attributeName,
defaultValue: defaultValue, outValue: outValue,
lookupType: lookupType)
let fnName {.used.} = n "GetFloatAttribute"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
boneName = param.boneName
attributeName = param.attributeName
outValue = param.outValue
return param.returnValue
proc getDisablePostProcessBlueprint*(self : USkeletalMeshComponentPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "GetDisablePostProcessBlueprint"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getDisableAnimCurves*(self : USkeletalMeshComponentPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "GetDisableAnimCurves"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getDefaultAnimatingRigOverride*(self : USkeletalMeshComponentPtr): TSoftObjectPtr[
UObject] {.exportcpp: "$1_".} =
type
Params = object
returnValue: TSoftObjectPtr[UObject]
var param = Params()
let fnName {.used.} = n "GetDefaultAnimatingRigOverride"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getDefaultAnimatingRig*(self : USkeletalMeshComponentPtr): TSoftObjectPtr[
UObject] {.exportcpp: "$1_".} =
type
Params = object
returnValue: TSoftObjectPtr[UObject]
var param = Params()
let fnName {.used.} = n "GetDefaultAnimatingRig"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getCurrentJointAngles*(self : USkeletalMeshComponentPtr;
inBoneName : FName;
swing1Angle : var float32;
twistAngle : var float32;
swing2Angle : var float32): void {.
exportcpp: "$1_".} =
type
Params = object
inBoneName: FName
swing1Angle: float32
twistAngle: float32
swing2Angle: float32
var param = Params(inBoneName: inBoneName,
swing1Angle: swing1Angle,
twistAngle: twistAngle, swing2Angle: swing2Angle)
let fnName {.used.} = n "GetCurrentJointAngles"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
swing1Angle = param.swing1Angle
twistAngle = param.twistAngle
swing2Angle = param.swing2Angle
proc getConstraintsFromBody*(self : USkeletalMeshComponentPtr;
bodyName : FName;
bParentConstraints : bool;
bChildConstraints : bool;
bIncludesTerminated : bool;
outConstraints : var TArray[FConstraintInstanceAccessor]): void {.
exportcpp: "$1_".} =
type
Params = object
bodyName: FName
bParentConstraints: bool
bChildConstraints: bool
bIncludesTerminated: bool
outConstraints: TArray[FConstraintInstanceAccessor]
var param = Params(bodyName: bodyName,
bParentConstraints: bParentConstraints,
bChildConstraints: bChildConstraints,
bIncludesTerminated: bIncludesTerminated,
outConstraints: outConstraints)
let fnName {.used.} = n "GetConstraintsFromBody"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
outConstraints = param.outConstraints
proc getConstraints*(self : USkeletalMeshComponentPtr;
bIncludesTerminated : bool;
outConstraints : var TArray[FConstraintInstanceAccessor]): void {.
exportcpp: "$1_".} =
type
Params = object
bIncludesTerminated: bool
outConstraints: TArray[FConstraintInstanceAccessor]
var param = Params(bIncludesTerminated: bIncludesTerminated,
outConstraints: outConstraints)
let fnName {.used.} = n "GetConstraints"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
outConstraints = param.outConstraints
proc getConstraintByName*(self : USkeletalMeshComponentPtr;
constraintName : FName;
bIncludesTerminated : bool): FConstraintInstanceAccessor {.
exportcpp: "$1_".} =
type
Params = object
constraintName: FName
bIncludesTerminated: bool
returnValue: FConstraintInstanceAccessor
var param = Params(constraintName: constraintName,
bIncludesTerminated: bIncludesTerminated)
let fnName {.used.} = n "GetConstraintByName"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getClothMaxDistanceScale*(self : USkeletalMeshComponentPtr): float32 {.
exportcpp: "$1_".} =
type
Params = object
returnValue: float32
var param = Params()
let fnName {.used.} = n "GetClothMaxDistanceScale"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getClothingSimulationInteractor*(self : USkeletalMeshComponentPtr): UClothingSimulationInteractorPtr {.
exportcpp: "$1_".} =
type
Params = object
returnValue: UClothingSimulationInteractorPtr
var param = Params()
let fnName {.used.} = n "GetClothingSimulationInteractor"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getBoneMass*(self : USkeletalMeshComponentPtr;
boneName : FName = makeFName("None");
bScaleMass : bool = true): float32 {.
exportcpp: "$1_".} =
type
Params = object
boneName: FName
bScaleMass: bool
returnValue: float32
var param = Params(boneName: boneName, bScaleMass: bScaleMass)
let fnName {.used.} = n "GetBoneMass"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getBoneLinearVelocity*(self : USkeletalMeshComponentPtr;
inBoneName : var FName): FVector {.
exportcpp: "$1_".} =
type
Params = object
inBoneName: FName
returnValue: FVector
var param = Params(inBoneName: inBoneName)
let fnName {.used.} = n "GetBoneLinearVelocity"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
inBoneName = param.inBoneName
return param.returnValue
proc getAnimInstance*(self : USkeletalMeshComponentPtr): UAnimInstancePtr {.
exportcpp: "$1_".} =
type
Params = object
returnValue: UAnimInstancePtr
var param = Params()
let fnName {.used.} = n "GetAnimInstance"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getAnimationMode*(self : USkeletalMeshComponentPtr): EAnimationMode {.
exportcpp: "$1_".} =
type
Params = object
returnValue: EAnimationMode
var param = Params()
let fnName {.used.} = n "GetAnimationMode"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getAllowRigidBodyAnimNode*(self : USkeletalMeshComponentPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "GetAllowRigidBodyAnimNode"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getAllowedAnimCurveEvaluate*(self : USkeletalMeshComponentPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "GetAllowedAnimCurveEvaluate"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getAllowClothActors*(self : USkeletalMeshComponentPtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "GetAllowClothActors"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc forceClothNextUpdateTeleportAndReset*(
self : USkeletalMeshComponentPtr): void {.exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "ForceClothNextUpdateTeleportAndReset"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc forceClothNextUpdateTeleport*(self : USkeletalMeshComponentPtr): void {.
exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "ForceClothNextUpdateTeleport"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc findConstraintBoneName*(self : USkeletalMeshComponentPtr;
constraintIndex : int32): FName {.
exportcpp: "$1_".} =
type
Params = object
constraintIndex: int32
returnValue: FName
var param = Params(constraintIndex: constraintIndex)
let fnName {.used.} = n "FindConstraintBoneName"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc clearMorphTargets*(self : USkeletalMeshComponentPtr): void {.
exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "ClearMorphTargets"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc breakConstraint*(self : USkeletalMeshComponentPtr;
impulse : FVector;
hitLocation : FVector;
inBoneName : FName): void {.exportcpp: "$1_".} =
type
Params = object
impulse: FVector
hitLocation: FVector
inBoneName: FName
var param = Params(impulse: impulse, hitLocation: hitLocation,
inBoneName: inBoneName)
let fnName {.used.} = n "BreakConstraint"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc bindClothToLeaderPoseComponent*(self : USkeletalMeshComponentPtr): void {.
exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "BindClothToLeaderPoseComponent"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc allowAnimCurveEvaluation*(self : USkeletalMeshComponentPtr;
nameOfCurve : FName;
bAllow : bool): void {.exportcpp: "$1_".} =
type
Params = object
nameOfCurve: FName
bAllow: bool
var param = Params(nameOfCurve: nameOfCurve, bAllow: bAllow)
let fnName {.used.} = n "AllowAnimCurveEvaluation"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc addImpulseToAllBodiesBelow*(self : USkeletalMeshComponentPtr;
impulse : FVector;
boneName : FName = makeFName("None");
bVelChange : bool = false;
bIncludeSelf : bool = true): void {.
exportcpp: "$1_".} =
type
Params = object
impulse: FVector
boneName: FName
bVelChange: bool
bIncludeSelf: bool
var param = Params(impulse: impulse, boneName: boneName,
bVelChange: bVelChange,
bIncludeSelf: bIncludeSelf)
let fnName {.used.} = n "AddImpulseToAllBodiesBelow"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc addForceToAllBodiesBelow*(self : USkeletalMeshComponentPtr;
force : FVector;
boneName : FName = makeFName("None");
bAccelChange : bool = false;
bIncludeSelf : bool = true): void {.
exportcpp: "$1_".} =
type
Params = object
force: FVector
boneName: FName
bAccelChange: bool
bIncludeSelf: bool
var param = Params(force: force, boneName: boneName,
bAccelChange: bAccelChange,
bIncludeSelf: bIncludeSelf)
let fnName {.used.} = n "AddForceToAllBodiesBelow"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc accumulateAllBodiesBelowPhysicsBlendWeight*(
self : USkeletalMeshComponentPtr; inBoneName : var FName;
addPhysicsBlendWeight : float32;
bSkipCustomPhysicsType : bool = false): void {.exportcpp: "$1_".} =
type
Params = object
inBoneName: FName
addPhysicsBlendWeight: float32
bSkipCustomPhysicsType: bool
var param = Params(inBoneName: inBoneName,
addPhysicsBlendWeight: addPhysicsBlendWeight,
bSkipCustomPhysicsType: bSkipCustomPhysicsType)
let fnName {.used.} = n "AccumulateAllBodiesBelowPhysicsBlendWeight"
let fn {.used.} = getClassByName("SkeletalMeshComponent").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
inBoneName = param.inBoneName
proc keepUSkeletalMeshComponent(fake : USkeletalMeshComponent) {.
exportcpp.} =
discard
converter USkeletalMeshComponenttoUInterface_CollisionDataProvider*(
self : USkeletalMeshComponentPtr): UInterface_CollisionDataProviderPtr =
cast[UInterface_CollisionDataProviderPtr](self)
proc wasAnimNotifyTriggeredInStateMachine*(self : UAnimInstancePtr;
machineIndex : int32;
animNotifyType : TSubclassOf[UAnimNotify]): bool {.
exportcpp: "$1_".} =
type
Params = object
machineIndex: int32
animNotifyType: TSubclassOf[UAnimNotify]
returnValue: bool
var param = Params(machineIndex: machineIndex,
animNotifyType: animNotifyType)
let fnName {.used.} = n "WasAnimNotifyTriggeredInStateMachine"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc wasAnimNotifyTriggeredInSourceState*(self : UAnimInstancePtr;
machineIndex : int32; stateIndex : int32;
animNotifyType : TSubclassOf[UAnimNotify]): bool {.
exportcpp: "$1_".} =
type
Params = object
machineIndex: int32
stateIndex: int32
animNotifyType: TSubclassOf[UAnimNotify]
returnValue: bool
var param = Params(machineIndex: machineIndex,
stateIndex: stateIndex,
animNotifyType: animNotifyType)
let fnName {.used.} = n "WasAnimNotifyTriggeredInSourceState"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc wasAnimNotifyTriggeredInAnyState*(self : UAnimInstancePtr;
animNotifyType : TSubclassOf[UAnimNotify]): bool {.
exportcpp: "$1_".} =
type
Params = object
animNotifyType: TSubclassOf[UAnimNotify]
returnValue: bool
var param = Params(animNotifyType: animNotifyType)
let fnName {.used.} = n "WasAnimNotifyTriggeredInAnyState"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc wasAnimNotifyStateActiveInStateMachine*(self : UAnimInstancePtr;
machineIndex : int32;
animNotifyStateType : TSubclassOf[UAnimNotifyState]): bool {.
exportcpp: "$1_".} =
type
Params = object
machineIndex: int32
animNotifyStateType: TSubclassOf[UAnimNotifyState]
returnValue: bool
var param = Params(machineIndex: machineIndex,
animNotifyStateType: animNotifyStateType)
let fnName {.used.} = n "WasAnimNotifyStateActiveInStateMachine"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc wasAnimNotifyStateActiveInSourceState*(self : UAnimInstancePtr;
machineIndex : int32; stateIndex : int32;
animNotifyStateType : TSubclassOf[UAnimNotifyState]): bool {.
exportcpp: "$1_".} =
type
Params = object
machineIndex: int32
stateIndex: int32
animNotifyStateType: TSubclassOf[UAnimNotifyState]
returnValue: bool
var param = Params(machineIndex: machineIndex,
stateIndex: stateIndex,
animNotifyStateType: animNotifyStateType)
let fnName {.used.} = n "WasAnimNotifyStateActiveInSourceState"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc wasAnimNotifyStateActiveInAnyState*(self : UAnimInstancePtr;
animNotifyStateType : TSubclassOf[UAnimNotifyState]): bool {.
exportcpp: "$1_".} =
type
Params = object
animNotifyStateType: TSubclassOf[UAnimNotifyState]
returnValue: bool
var param = Params(animNotifyStateType: animNotifyStateType)
let fnName {.used.} = n "WasAnimNotifyStateActiveInAnyState"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc wasAnimNotifyNameTriggeredInStateMachine*(self : UAnimInstancePtr;
machineIndex : int32; notifyName : FName): bool {.
exportcpp: "$1_".} =
type
Params = object
machineIndex: int32
notifyName: FName
returnValue: bool
var param = Params(machineIndex: machineIndex,
notifyName: notifyName)
let fnName {.used.} = n "WasAnimNotifyNameTriggeredInStateMachine"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc wasAnimNotifyNameTriggeredInSourceState*(self : UAnimInstancePtr;
machineIndex : int32; stateIndex : int32;
notifyName : FName): bool {.exportcpp: "$1_".} =
type
Params = object
machineIndex: int32
stateIndex: int32
notifyName: FName
returnValue: bool
var param = Params(machineIndex: machineIndex,
stateIndex: stateIndex, notifyName: notifyName)
let fnName {.used.} = n "WasAnimNotifyNameTriggeredInSourceState"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc wasAnimNotifyNameTriggeredInAnyState*(self : UAnimInstancePtr;
notifyName : FName): bool {.exportcpp: "$1_".} =
type
Params = object
notifyName: FName
returnValue: bool
var param = Params(notifyName: notifyName)
let fnName {.used.} = n "WasAnimNotifyNameTriggeredInAnyState"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc unlockAIResources*(self : UAnimInstancePtr;
bUnlockMovement : bool;
unlockAILogic : bool): void {.exportcpp: "$1_".} =
type
Params = object
bUnlockMovement: bool
unlockAILogic: bool
var param = Params(bUnlockMovement: bUnlockMovement,
unlockAILogic: unlockAILogic)
let fnName {.used.} = n "UnlockAIResources"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc unlinkAnimClassLayers*(self : UAnimInstancePtr;
inClass : TSubclassOf[UAnimInstance]): void {.
exportcpp: "$1_".} =
type
Params = object
inClass: TSubclassOf[UAnimInstance]
var param = Params(inClass: inClass)
let fnName {.used.} = n "UnlinkAnimClassLayers"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc tryGetPawnOwner*(self : UAnimInstancePtr): APawnPtr {.
exportcpp: "$1_".} =
type
Params = object
returnValue: APawnPtr
var param = Params()
let fnName {.used.} = n "TryGetPawnOwner"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc stopSlotAnimation*(self : UAnimInstancePtr;
inBlendOutTime : float32 = 0.25'f32;
slotNodeName : FName = makeFName("None")): void {.
exportcpp: "$1_".} =
type
Params = object
inBlendOutTime: float32
slotNodeName: FName
var param = Params(inBlendOutTime: inBlendOutTime,
slotNodeName: slotNodeName)
let fnName {.used.} = n "StopSlotAnimation"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc snapshotPose*(self : UAnimInstancePtr;
snapshot : var FPoseSnapshot): void {.
exportcpp: "$1_".} =
type
Params = object
snapshot: FPoseSnapshot
var param = Params(snapshot: snapshot)
let fnName {.used.} = n "SnapshotPose"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
snapshot = param.snapshot
proc setUseMainInstanceMontageEvaluationData*(self : UAnimInstancePtr;
bSet : bool): void {.exportcpp: "$1_".} =
type
Params = object
bSet: bool
var param = Params(bSet: bSet)
let fnName {.used.} = n "SetUseMainInstanceMontageEvaluationData"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setRootMotionMode*(self : UAnimInstancePtr;
value : ERootMotionMode): void {.
exportcpp: "$1_".} =
type
Params = object
value: ERootMotionMode
var param = Params(value: value)
let fnName {.used.} = n "SetRootMotionMode"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setReceiveNotifiesFromLinkedInstances*(self : UAnimInstancePtr;
bSet : bool): void {.exportcpp: "$1_".} =
type
Params = object
bSet: bool
var param = Params(bSet: bSet)
let fnName {.used.} = n "SetReceiveNotifiesFromLinkedInstances"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setPropagateNotifiesToLinkedInstances*(self : UAnimInstancePtr;
bSet : bool): void {.exportcpp: "$1_".} =
type
Params = object
bSet: bool
var param = Params(bSet: bSet)
let fnName {.used.} = n "SetPropagateNotifiesToLinkedInstances"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setMorphTarget*(self : UAnimInstancePtr;
morphTargetName : FName; value : float32): void {.
exportcpp: "$1_".} =
type
Params = object
morphTargetName: FName
value: float32
var param = Params(morphTargetName: morphTargetName, value: value)
let fnName {.used.} = n "SetMorphTarget"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc savePoseSnapshot*(self : UAnimInstancePtr;
snapshotName : FName): void {.exportcpp: "$1_".} =
type
Params = object
snapshotName: FName
var param = Params(snapshotName: snapshotName)
let fnName {.used.} = n "SavePoseSnapshot"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc resetDynamics*(self : UAnimInstancePtr;
inTeleportType : ETeleportType): void {.
exportcpp: "$1_".} =
type
Params = object
inTeleportType: ETeleportType
var param = Params(inTeleportType: inTeleportType)
let fnName {.used.} = n "ResetDynamics"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc requestTransitionEvent*(self : UAnimInstancePtr;
eventName : FName;
requestTimeout : float64;
queueMode : ETransitionRequestQueueMode;
overwriteMode : ETransitionRequestOverwriteMode): bool {.
exportcpp: "$1_".} =
type
Params = object
eventName: FName
requestTimeout: float64
queueMode: ETransitionRequestQueueMode
overwriteMode: ETransitionRequestOverwriteMode
returnValue: bool
var param = Params(eventName: eventName,
requestTimeout: requestTimeout,
queueMode: queueMode,
overwriteMode: overwriteMode)
let fnName {.used.} = n "RequestTransitionEvent"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc requestSlotGroupInertialization*(self : UAnimInstancePtr;
inSlotGroupName : FName;
duration : float32;
blendProfile : UBlendProfilePtr = nil): void {.exportcpp: "$1_".} =
type
Params = object
inSlotGroupName: FName
duration: float32
blendProfile: UBlendProfilePtr
var param = Params(inSlotGroupName: inSlotGroupName,
duration: duration, blendProfile: blendProfile)
let fnName {.used.} = n "RequestSlotGroupInertialization"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc removePoseSnapshot*(self : UAnimInstancePtr;
snapshotName : FName): void {.
exportcpp: "$1_".} =
type
Params = object
snapshotName: FName
var param = Params(snapshotName: snapshotName)
let fnName {.used.} = n "RemovePoseSnapshot"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc queryTransitionEvent*(self : UAnimInstancePtr;
machineIndex : int32;
transitionIndex : int32;
eventName : FName): bool {.exportcpp: "$1_".} =
type
Params = object
machineIndex: int32
transitionIndex: int32
eventName: FName
returnValue: bool
var param = Params(machineIndex: machineIndex,
transitionIndex: transitionIndex,
eventName: eventName)
let fnName {.used.} = n "QueryTransitionEvent"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc queryAndMarkTransitionEvent*(self : UAnimInstancePtr;
machineIndex : int32;
transitionIndex : int32;
eventName : FName): bool {.
exportcpp: "$1_".} =
type
Params = object
machineIndex: int32
transitionIndex: int32
eventName: FName
returnValue: bool
var param = Params(machineIndex: machineIndex,
transitionIndex: transitionIndex,
eventName: eventName)
let fnName {.used.} = n "QueryAndMarkTransitionEvent"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc playSlotAnimationAsDynamicMontage_WithBlendSettings*(
self : UAnimInstancePtr; asset : UAnimSequenceBasePtr;
slotNodeName : FName;
blendInSettings : var FMontageBlendSettings;
blendOutSettings : var FMontageBlendSettings;
inPlayRate : float32 = 1.0'f32;
loopCount : int32 = 1'i32;
blendOutTriggerTime : float32 = -1.0'f32;
inTimeToStartMontageAt : float32 = 0.0'f32): UAnimMontagePtr {.
exportcpp: "$1_".} =
type
Params = object
asset: UAnimSequenceBasePtr
slotNodeName: FName
blendInSettings: FMontageBlendSettings
blendOutSettings: FMontageBlendSettings
inPlayRate: float32
loopCount: int32
blendOutTriggerTime: float32
inTimeToStartMontageAt: float32
returnValue: UAnimMontagePtr
var param = Params(asset: asset, slotNodeName: slotNodeName,
blendInSettings: blendInSettings,
blendOutSettings: blendOutSettings,
inPlayRate: inPlayRate, loopCount: loopCount,
blendOutTriggerTime: blendOutTriggerTime,
inTimeToStartMontageAt: inTimeToStartMontageAt)
let fnName {.used.} = n "PlaySlotAnimationAsDynamicMontage_WithBlendSettings"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
blendInSettings = param.blendInSettings
blendOutSettings = param.blendOutSettings
return param.returnValue
proc playSlotAnimationAsDynamicMontage_WithBlendArgs*(
self : UAnimInstancePtr; asset : UAnimSequenceBasePtr;
slotNodeName : FName; blendIn : var FAlphaBlendArgs;
blendOut : var FAlphaBlendArgs;
inPlayRate : float32 = 1.0'f32;
loopCount : int32 = 1'i32;
blendOutTriggerTime : float32 = -1.0'f32;
inTimeToStartMontageAt : float32 = 0.0'f32): UAnimMontagePtr {.
exportcpp: "$1_".} =
type
Params = object
asset: UAnimSequenceBasePtr
slotNodeName: FName
blendIn: FAlphaBlendArgs
blendOut: FAlphaBlendArgs
inPlayRate: float32
loopCount: int32
blendOutTriggerTime: float32
inTimeToStartMontageAt: float32
returnValue: UAnimMontagePtr
var param = Params(asset: asset, slotNodeName: slotNodeName,
blendIn: blendIn, blendOut: blendOut,
inPlayRate: inPlayRate, loopCount: loopCount,
blendOutTriggerTime: blendOutTriggerTime,
inTimeToStartMontageAt: inTimeToStartMontageAt)
let fnName {.used.} = n "PlaySlotAnimationAsDynamicMontage_WithBlendArgs"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
blendIn = param.blendIn
blendOut = param.blendOut
return param.returnValue
proc playSlotAnimationAsDynamicMontage*(self : UAnimInstancePtr;
asset : UAnimSequenceBasePtr;
slotNodeName : FName;
blendInTime : float32 = 0.25'f32; blendOutTime : float32 = 0.25'f32;
inPlayRate : float32 = 1.0'f32;
loopCount : int32 = 1'i32;
blendOutTriggerTime : float32 = -1.0'f32;
inTimeToStartMontageAt : float32 = 0.0'f32): UAnimMontagePtr {.
exportcpp: "$1_".} =
type
Params = object
asset: UAnimSequenceBasePtr
slotNodeName: FName
blendInTime: float32
blendOutTime: float32
inPlayRate: float32
loopCount: int32
blendOutTriggerTime: float32
inTimeToStartMontageAt: float32
returnValue: UAnimMontagePtr
var param = Params(asset: asset, slotNodeName: slotNodeName,
blendInTime: blendInTime,
blendOutTime: blendOutTime,
inPlayRate: inPlayRate, loopCount: loopCount,
blendOutTriggerTime: blendOutTriggerTime,
inTimeToStartMontageAt: inTimeToStartMontageAt)
let fnName {.used.} = n "PlaySlotAnimationAsDynamicMontage"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc montageSync_StopFollowing*(self : UAnimInstancePtr;
montageFollower : UAnimMontagePtr): void {.
exportcpp: "$1_".} =
type
Params = object
montageFollower: UAnimMontagePtr
var param = Params(montageFollower: montageFollower)
let fnName {.used.} = n "MontageSync_StopFollowing"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc montageSync_Follow*(self : UAnimInstancePtr;
montageFollower : UAnimMontagePtr;
otherAnimInstance : UAnimInstancePtr;
montageLeader : UAnimMontagePtr): void {.
exportcpp: "$1_".} =
type
Params = object
montageFollower: UAnimMontagePtr
otherAnimInstance: UAnimInstancePtr
montageLeader: UAnimMontagePtr
var param = Params(montageFollower: montageFollower,
otherAnimInstance: otherAnimInstance,
montageLeader: montageLeader)
let fnName {.used.} = n "MontageSync_Follow"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc montage_StopWithBlendSettings*(self : UAnimInstancePtr;
blendOutSettings : var FMontageBlendSettings;
montage : UAnimMontagePtr = nil): void {.
exportcpp: "$1_".} =
type
Params = object
blendOutSettings: FMontageBlendSettings
montage: UAnimMontagePtr
var param = Params(blendOutSettings: blendOutSettings,
montage: montage)
let fnName {.used.} = n "Montage_StopWithBlendSettings"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
blendOutSettings = param.blendOutSettings
proc montage_StopWithBlendOut*(self : UAnimInstancePtr;
blendOut : var FAlphaBlendArgs;
montage : UAnimMontagePtr = nil): void {.
exportcpp: "$1_".} =
type
Params = object
blendOut: FAlphaBlendArgs
montage: UAnimMontagePtr
var param = Params(blendOut: blendOut, montage: montage)
let fnName {.used.} = n "Montage_StopWithBlendOut"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
blendOut = param.blendOut
proc montage_StopGroupByName*(self : UAnimInstancePtr;
inBlendOutTime : float32;
groupName : FName): void {.
exportcpp: "$1_".} =
type
Params = object
inBlendOutTime: float32
groupName: FName
var param = Params(inBlendOutTime: inBlendOutTime,
groupName: groupName)
let fnName {.used.} = n "Montage_StopGroupByName"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc montage_Stop*(self : UAnimInstancePtr;
inBlendOutTime : float32;
montage : UAnimMontagePtr = nil): void {.
exportcpp: "$1_".} =
type
Params = object
inBlendOutTime: float32
montage: UAnimMontagePtr
var param = Params(inBlendOutTime: inBlendOutTime, montage: montage)
let fnName {.used.} = n "Montage_Stop"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc montage_SetPosition*(self : UAnimInstancePtr;
montage : UAnimMontagePtr;
newPosition : float32): void {.
exportcpp: "$1_".} =
type
Params = object
montage: UAnimMontagePtr
newPosition: float32
var param = Params(montage: montage, newPosition: newPosition)
let fnName {.used.} = n "Montage_SetPosition"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc montage_SetPlayRate*(self : UAnimInstancePtr;
montage : UAnimMontagePtr;
newPlayRate : float32 = 1.0'f32): void {.
exportcpp: "$1_".} =
type
Params = object
montage: UAnimMontagePtr
newPlayRate: float32
var param = Params(montage: montage, newPlayRate: newPlayRate)
let fnName {.used.} = n "Montage_SetPlayRate"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc montage_SetNextSection*(self : UAnimInstancePtr;
sectionNameToChange : FName;
nextSection : FName;
montage : UAnimMontagePtr = nil): void {.
exportcpp: "$1_".} =
type
Params = object
sectionNameToChange: FName
nextSection: FName
montage: UAnimMontagePtr
var param = Params(sectionNameToChange: sectionNameToChange,
nextSection: nextSection, montage: montage)
let fnName {.used.} = n "Montage_SetNextSection"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc montage_Resume*(self : UAnimInstancePtr;
montage : UAnimMontagePtr): void {.
exportcpp: "$1_".} =
type
Params = object
montage: UAnimMontagePtr
var param = Params(montage: montage)
let fnName {.used.} = n "Montage_Resume"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc montage_PlayWithBlendSettings*(self : UAnimInstancePtr;
montageToPlay : UAnimMontagePtr;
blendInSettings : var FMontageBlendSettings;
inPlayRate : float32 = 1.0'f32;
returnValueType : EMontagePlayReturnType = EMontagePlayReturnType.MontageLength;
inTimeToStartMontageAt : float32 = 0.0'f32;
bStopAllMontages : bool = true): float32 {.
exportcpp: "$1_".} =
type
Params = object
montageToPlay: UAnimMontagePtr
blendInSettings: FMontageBlendSettings
inPlayRate: float32
returnValueType: EMontagePlayReturnType
inTimeToStartMontageAt: float32
bStopAllMontages: bool
returnValue: float32
var param = Params(montageToPlay: montageToPlay,
blendInSettings: blendInSettings,
inPlayRate: inPlayRate,
returnValueType: returnValueType,
inTimeToStartMontageAt: inTimeToStartMontageAt,
bStopAllMontages: bStopAllMontages)
let fnName {.used.} = n "Montage_PlayWithBlendSettings"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
blendInSettings = param.blendInSettings
return param.returnValue
proc montage_PlayWithBlendIn*(self : UAnimInstancePtr;
montageToPlay : UAnimMontagePtr;
blendIn : var FAlphaBlendArgs;
inPlayRate : float32 = 1.0'f32;
returnValueType : EMontagePlayReturnType = EMontagePlayReturnType.MontageLength;
inTimeToStartMontageAt : float32 = 0.0'f32;
bStopAllMontages : bool = true): float32 {.
exportcpp: "$1_".} =
type
Params = object
montageToPlay: UAnimMontagePtr
blendIn: FAlphaBlendArgs
inPlayRate: float32
returnValueType: EMontagePlayReturnType
inTimeToStartMontageAt: float32
bStopAllMontages: bool
returnValue: float32
var param = Params(montageToPlay: montageToPlay, blendIn: blendIn,
inPlayRate: inPlayRate,
returnValueType: returnValueType,
inTimeToStartMontageAt: inTimeToStartMontageAt,
bStopAllMontages: bStopAllMontages)
let fnName {.used.} = n "Montage_PlayWithBlendIn"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
blendIn = param.blendIn
return param.returnValue
proc montage_Play*(self : UAnimInstancePtr;
montageToPlay : UAnimMontagePtr;
inPlayRate : float32 = 1.0'f32;
returnValueType : EMontagePlayReturnType = EMontagePlayReturnType.MontageLength;
inTimeToStartMontageAt : float32 = 0.0'f32;
bStopAllMontages : bool = true): float32 {.
exportcpp: "$1_".} =
type
Params = object
montageToPlay: UAnimMontagePtr
inPlayRate: float32
returnValueType: EMontagePlayReturnType
inTimeToStartMontageAt: float32
bStopAllMontages: bool
returnValue: float32
var param = Params(montageToPlay: montageToPlay,
inPlayRate: inPlayRate,
returnValueType: returnValueType,
inTimeToStartMontageAt: inTimeToStartMontageAt,
bStopAllMontages: bStopAllMontages)
let fnName {.used.} = n "Montage_Play"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc montage_Pause*(self : UAnimInstancePtr;
montage : UAnimMontagePtr = nil): void {.
exportcpp: "$1_".} =
type
Params = object
montage: UAnimMontagePtr
var param = Params(montage: montage)
let fnName {.used.} = n "Montage_Pause"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc montage_JumpToSectionsEnd*(self : UAnimInstancePtr;
sectionName : FName;
montage : UAnimMontagePtr = nil): void {.
exportcpp: "$1_".} =
type
Params = object
sectionName: FName
montage: UAnimMontagePtr
var param = Params(sectionName: sectionName, montage: montage)
let fnName {.used.} = n "Montage_JumpToSectionsEnd"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc montage_JumpToSection*(self : UAnimInstancePtr;
sectionName : FName;
montage : UAnimMontagePtr = nil): void {.
exportcpp: "$1_".} =
type
Params = object
sectionName: FName
montage: UAnimMontagePtr
var param = Params(sectionName: sectionName, montage: montage)
let fnName {.used.} = n "Montage_JumpToSection"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc montage_IsPlaying*(self : UAnimInstancePtr;
montage : UAnimMontagePtr): bool {.
exportcpp: "$1_".} =
type
Params = object
montage: UAnimMontagePtr
returnValue: bool
var param = Params(montage: montage)
let fnName {.used.} = n "Montage_IsPlaying"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc montage_IsActive*(self : UAnimInstancePtr;
montage : UAnimMontagePtr): bool {.
exportcpp: "$1_".} =
type
Params = object
montage: UAnimMontagePtr
returnValue: bool
var param = Params(montage: montage)
let fnName {.used.} = n "Montage_IsActive"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc montage_GetPosition*(self : UAnimInstancePtr;
montage : UAnimMontagePtr): float32 {.
exportcpp: "$1_".} =
type
Params = object
montage: UAnimMontagePtr
returnValue: float32
var param = Params(montage: montage)
let fnName {.used.} = n "Montage_GetPosition"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc montage_GetPlayRate*(self : UAnimInstancePtr;
montage : UAnimMontagePtr): float32 {.
exportcpp: "$1_".} =
type
Params = object
montage: UAnimMontagePtr
returnValue: float32
var param = Params(montage: montage)
let fnName {.used.} = n "Montage_GetPlayRate"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc montage_GetIsStopped*(self : UAnimInstancePtr;
montage : UAnimMontagePtr): bool {.
exportcpp: "$1_".} =
type
Params = object
montage: UAnimMontagePtr
returnValue: bool
var param = Params(montage: montage)
let fnName {.used.} = n "Montage_GetIsStopped"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc montage_GetCurrentSection*(self : UAnimInstancePtr;
montage : UAnimMontagePtr = nil): FName {.
exportcpp: "$1_".} =
type
Params = object
montage: UAnimMontagePtr
returnValue: FName
var param = Params(montage: montage)
let fnName {.used.} = n "Montage_GetCurrentSection"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc montage_GetBlendTime*(self : UAnimInstancePtr;
montage : UAnimMontagePtr): float32 {.
exportcpp: "$1_".} =
type
Params = object
montage: UAnimMontagePtr
returnValue: float32
var param = Params(montage: montage)
let fnName {.used.} = n "Montage_GetBlendTime"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc lockAIResources*(self : UAnimInstancePtr;
bLockMovement : bool;
lockAILogic : bool): void {.exportcpp: "$1_".} =
type
Params = object
bLockMovement: bool
lockAILogic: bool
var param = Params(bLockMovement: bLockMovement,
lockAILogic: lockAILogic)
let fnName {.used.} = n "LockAIResources"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc linkAnimGraphByTag*(self : UAnimInstancePtr;
inTag : FName;
inClass : TSubclassOf[UAnimInstance]): void {.
exportcpp: "$1_".} =
type
Params = object
inTag: FName
inClass: TSubclassOf[UAnimInstance]
var param = Params(inTag: inTag, inClass: inClass)
let fnName {.used.} = n "LinkAnimGraphByTag"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc linkAnimClassLayers*(self : UAnimInstancePtr;
inClass : TSubclassOf[UAnimInstance]): void {.
exportcpp: "$1_".} =
type
Params = object
inClass: TSubclassOf[UAnimInstance]
var param = Params(inClass: inClass)
let fnName {.used.} = n "LinkAnimClassLayers"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc isUsingMainInstanceMontageEvaluationData*(self : UAnimInstancePtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsUsingMainInstanceMontageEvaluationData"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isSyncGroupBetweenMarkers*(self : UAnimInstancePtr;
inSyncGroupName : FName;
previousMarker : FName;
nextMarker : FName;
bRespectMarkerOrder : bool = true): bool {.
exportcpp: "$1_".} =
type
Params = object
inSyncGroupName: FName
previousMarker: FName
nextMarker: FName
bRespectMarkerOrder: bool
returnValue: bool
var param = Params(inSyncGroupName: inSyncGroupName,
previousMarker: previousMarker,
nextMarker: nextMarker,
bRespectMarkerOrder: bRespectMarkerOrder)
let fnName {.used.} = n "IsSyncGroupBetweenMarkers"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isPlayingSlotAnimation*(self : UAnimInstancePtr;
asset : UAnimSequenceBasePtr;
slotNodeName : FName): bool {.
exportcpp: "$1_".} =
type
Params = object
asset: UAnimSequenceBasePtr
slotNodeName: FName
returnValue: bool
var param = Params(asset: asset, slotNodeName: slotNodeName)
let fnName {.used.} = n "IsPlayingSlotAnimation"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc isAnyMontagePlaying*(self : UAnimInstancePtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "IsAnyMontagePlaying"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc hasMarkerBeenHitThisFrame*(self : UAnimInstancePtr;
syncGroup : FName;
markerName : FName): bool {.
exportcpp: "$1_".} =
type
Params = object
syncGroup: FName
markerName: FName
returnValue: bool
var param = Params(syncGroup: syncGroup, markerName: markerName)
let fnName {.used.} = n "HasMarkerBeenHitThisFrame"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getTimeToClosestMarker*(self : UAnimInstancePtr;
syncGroup : FName;
markerName : FName;
outMarkerTime : var float32): bool {.
exportcpp: "$1_".} =
type
Params = object
syncGroup: FName
markerName: FName
outMarkerTime: float32
returnValue: bool
var param = Params(syncGroup: syncGroup, markerName: markerName,
outMarkerTime: outMarkerTime)
let fnName {.used.} = n "GetTimeToClosestMarker"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
outMarkerTime = param.outMarkerTime
return param.returnValue
proc getSyncGroupPosition*(self : UAnimInstancePtr;
inSyncGroupName : FName): FMarkerSyncAnimPosition {.
exportcpp: "$1_".} =
type
Params = object
inSyncGroupName: FName
returnValue: FMarkerSyncAnimPosition
var param = Params(inSyncGroupName: inSyncGroupName)
let fnName {.used.} = n "GetSyncGroupPosition"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getRelevantAnimTimeRemainingFraction*(self : UAnimInstancePtr;
machineIndex : int32; stateIndex : int32): float32 {.
exportcpp: "$1_".} =
type
Params = object
machineIndex: int32
stateIndex: int32
returnValue: float32
var param = Params(machineIndex: machineIndex,
stateIndex: stateIndex)
let fnName {.used.} = n "GetRelevantAnimTimeRemainingFraction"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getRelevantAnimTimeRemaining*(self : UAnimInstancePtr;
machineIndex : int32;
stateIndex : int32): float32 {.
exportcpp: "$1_".} =
type
Params = object
machineIndex: int32
stateIndex: int32
returnValue: float32
var param = Params(machineIndex: machineIndex,
stateIndex: stateIndex)
let fnName {.used.} = n "GetRelevantAnimTimeRemaining"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getRelevantAnimTimeFraction*(self : UAnimInstancePtr;
machineIndex : int32;
stateIndex : int32): float32 {.
exportcpp: "$1_".} =
type
Params = object
machineIndex: int32
stateIndex: int32
returnValue: float32
var param = Params(machineIndex: machineIndex,
stateIndex: stateIndex)
let fnName {.used.} = n "GetRelevantAnimTimeFraction"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getRelevantAnimTime*(self : UAnimInstancePtr;
machineIndex : int32;
stateIndex : int32): float32 {.
exportcpp: "$1_".} =
type
Params = object
machineIndex: int32
stateIndex: int32
returnValue: float32
var param = Params(machineIndex: machineIndex,
stateIndex: stateIndex)
let fnName {.used.} = n "GetRelevantAnimTime"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getRelevantAnimLength*(self : UAnimInstancePtr;
machineIndex : int32;
stateIndex : int32): float32 {.
exportcpp: "$1_".} =
type
Params = object
machineIndex: int32
stateIndex: int32
returnValue: float32
var param = Params(machineIndex: machineIndex,
stateIndex: stateIndex)
let fnName {.used.} = n "GetRelevantAnimLength"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getReceiveNotifiesFromLinkedInstances*(self : UAnimInstancePtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "GetReceiveNotifiesFromLinkedInstances"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getPropagateNotifiesToLinkedInstances*(self : UAnimInstancePtr): bool {.
exportcpp: "$1_".} =
type
Params = object
returnValue: bool
var param = Params()
let fnName {.used.} = n "GetPropagateNotifiesToLinkedInstances"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getOwningComponent*(self : UAnimInstancePtr): USkeletalMeshComponentPtr {.
exportcpp: "$1_".} =
type
Params = object
returnValue: USkeletalMeshComponentPtr
var param = Params()
let fnName {.used.} = n "GetOwningComponent"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getOwningActor*(self : UAnimInstancePtr): AActorPtr {.
exportcpp: "$1_".} =
type
Params = object
returnValue: AActorPtr
var param = Params()
let fnName {.used.} = n "GetOwningActor"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getLinkedAnimLayerInstancesByGroup*(self : UAnimInstancePtr;
inGroup : FName;
outLinkedInstances : var TArray[UAnimInstancePtr]): void {.
exportcpp: "$1_".} =
type
Params = object
inGroup: FName
outLinkedInstances: TArray[UAnimInstancePtr]
var param = Params(inGroup: inGroup,
outLinkedInstances: outLinkedInstances)
let fnName {.used.} = n "GetLinkedAnimLayerInstancesByGroup"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
outLinkedInstances = param.outLinkedInstances
proc getLinkedAnimLayerInstanceByGroupAndClass*(
self : UAnimInstancePtr; inGroup : FName;
inClass : TSubclassOf[UAnimInstance]): UAnimInstancePtr {.
exportcpp: "$1_".} =
type
Params = object
inGroup: FName
inClass: TSubclassOf[UAnimInstance]
returnValue: UAnimInstancePtr
var param = Params(inGroup: inGroup, inClass: inClass)
let fnName {.used.} = n "GetLinkedAnimLayerInstanceByGroupAndClass"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getLinkedAnimLayerInstanceByGroup*(self : UAnimInstancePtr;
inGroup : FName): UAnimInstancePtr {.
exportcpp: "$1_".} =
type
Params = object
inGroup: FName
returnValue: UAnimInstancePtr
var param = Params(inGroup: inGroup)
let fnName {.used.} = n "GetLinkedAnimLayerInstanceByGroup"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getLinkedAnimLayerInstanceByClass*(self : UAnimInstancePtr;
inClass : TSubclassOf[UAnimInstance]): UAnimInstancePtr {.
exportcpp: "$1_".} =
type
Params = object
inClass: TSubclassOf[UAnimInstance]
returnValue: UAnimInstancePtr
var param = Params(inClass: inClass)
let fnName {.used.} = n "GetLinkedAnimLayerInstanceByClass"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getLinkedAnimGraphInstancesByTag*(self : UAnimInstancePtr;
inTag : FName;
outLinkedInstances : var TArray[UAnimInstancePtr]): void {.
exportcpp: "$1_".} =
type
Params = object
inTag: FName
outLinkedInstances: TArray[UAnimInstancePtr]
var param = Params(inTag: inTag,
outLinkedInstances: outLinkedInstances)
let fnName {.used.} = n "GetLinkedAnimGraphInstancesByTag"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
outLinkedInstances = param.outLinkedInstances
proc getLinkedAnimGraphInstanceByTag*(self : UAnimInstancePtr;
inTag : FName): UAnimInstancePtr {.
exportcpp: "$1_".} =
type
Params = object
inTag: FName
returnValue: UAnimInstancePtr
var param = Params(inTag: inTag)
let fnName {.used.} = n "GetLinkedAnimGraphInstanceByTag"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getInstanceTransitionTimeElapsedFraction*(self : UAnimInstancePtr;
machineIndex : int32; transitionIndex : int32): float32 {.
exportcpp: "$1_".} =
type
Params = object
machineIndex: int32
transitionIndex: int32
returnValue: float32
var param = Params(machineIndex: machineIndex,
transitionIndex: transitionIndex)
let fnName {.used.} = n "GetInstanceTransitionTimeElapsedFraction"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getInstanceTransitionTimeElapsed*(self : UAnimInstancePtr;
machineIndex : int32;
transitionIndex : int32): float32 {.
exportcpp: "$1_".} =
type
Params = object
machineIndex: int32
transitionIndex: int32
returnValue: float32
var param = Params(machineIndex: machineIndex,
transitionIndex: transitionIndex)
let fnName {.used.} = n "GetInstanceTransitionTimeElapsed"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getInstanceTransitionCrossfadeDuration*(self : UAnimInstancePtr;
machineIndex : int32; transitionIndex : int32): float32 {.
exportcpp: "$1_".} =
type
Params = object
machineIndex: int32
transitionIndex: int32
returnValue: float32
var param = Params(machineIndex: machineIndex,
transitionIndex: transitionIndex)
let fnName {.used.} = n "GetInstanceTransitionCrossfadeDuration"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getInstanceStateWeight*(self : UAnimInstancePtr;
machineIndex : int32;
stateIndex : int32): float32 {.
exportcpp: "$1_".} =
type
Params = object
machineIndex: int32
stateIndex: int32
returnValue: float32
var param = Params(machineIndex: machineIndex,
stateIndex: stateIndex)
let fnName {.used.} = n "GetInstanceStateWeight"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getInstanceMachineWeight*(self : UAnimInstancePtr;
machineIndex : int32): float32 {.
exportcpp: "$1_".} =
type
Params = object
machineIndex: int32
returnValue: float32
var param = Params(machineIndex: machineIndex)
let fnName {.used.} = n "GetInstanceMachineWeight"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getInstanceCurrentStateElapsedTime*(self : UAnimInstancePtr;
machineIndex : int32): float32 {.exportcpp: "$1_".} =
type
Params = object
machineIndex: int32
returnValue: float32
var param = Params(machineIndex: machineIndex)
let fnName {.used.} = n "GetInstanceCurrentStateElapsedTime"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getInstanceAssetPlayerTimeFromEndFraction*(
self : UAnimInstancePtr; assetPlayerIndex : int32): float32 {.
exportcpp: "$1_".} =
type
Params = object
assetPlayerIndex: int32
returnValue: float32
var param = Params(assetPlayerIndex: assetPlayerIndex)
let fnName {.used.} = n "GetInstanceAssetPlayerTimeFromEndFraction"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getInstanceAssetPlayerTimeFromEnd*(self : UAnimInstancePtr;
assetPlayerIndex : int32): float32 {.
exportcpp: "$1_".} =
type
Params = object
assetPlayerIndex: int32
returnValue: float32
var param = Params(assetPlayerIndex: assetPlayerIndex)
let fnName {.used.} = n "GetInstanceAssetPlayerTimeFromEnd"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getInstanceAssetPlayerTimeFraction*(self : UAnimInstancePtr;
assetPlayerIndex : int32): float32 {.exportcpp: "$1_".} =
type
Params = object
assetPlayerIndex: int32
returnValue: float32
var param = Params(assetPlayerIndex: assetPlayerIndex)
let fnName {.used.} = n "GetInstanceAssetPlayerTimeFraction"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getInstanceAssetPlayerTime*(self : UAnimInstancePtr;
assetPlayerIndex : int32): float32 {.
exportcpp: "$1_".} =
type
Params = object
assetPlayerIndex: int32
returnValue: float32
var param = Params(assetPlayerIndex: assetPlayerIndex)
let fnName {.used.} = n "GetInstanceAssetPlayerTime"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getInstanceAssetPlayerLength*(self : UAnimInstancePtr;
assetPlayerIndex : int32): float32 {.
exportcpp: "$1_".} =
type
Params = object
assetPlayerIndex: int32
returnValue: float32
var param = Params(assetPlayerIndex: assetPlayerIndex)
let fnName {.used.} = n "GetInstanceAssetPlayerLength"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getDeltaSeconds*(self : UAnimInstancePtr): float32 {.
exportcpp: "$1_".} =
type
Params = object
returnValue: float32
var param = Params()
let fnName {.used.} = n "GetDeltaSeconds"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getCurveValueWithDefault*(self : UAnimInstancePtr;
curveName : FName;
defaultValue : float32;
outValue : var float32): bool {.
exportcpp: "$1_".} =
type
Params = object
curveName: FName
defaultValue: float32
outValue: float32
returnValue: bool
var param = Params(curveName: curveName,
defaultValue: defaultValue, outValue: outValue)
let fnName {.used.} = n "GetCurveValueWithDefault"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
outValue = param.outValue
return param.returnValue
proc getCurveValue*(self : UAnimInstancePtr;
curveName : FName): float32 {.exportcpp: "$1_".} =
type
Params = object
curveName: FName
returnValue: float32
var param = Params(curveName: curveName)
let fnName {.used.} = n "GetCurveValue"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getCurrentStateName*(self : UAnimInstancePtr;
machineIndex : int32): FName {.
exportcpp: "$1_".} =
type
Params = object
machineIndex: int32
returnValue: FName
var param = Params(machineIndex: machineIndex)
let fnName {.used.} = n "GetCurrentStateName"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getCurrentActiveMontage*(self : UAnimInstancePtr): UAnimMontagePtr {.
exportcpp: "$1_".} =
type
Params = object
returnValue: UAnimMontagePtr
var param = Params()
let fnName {.used.} = n "GetCurrentActiveMontage"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getAllCurveNames*(self : UAnimInstancePtr;
outNames : var TArray[FName]): void {.
exportcpp: "$1_".} =
type
Params = object
outNames: TArray[FName]
var param = Params(outNames: outNames)
let fnName {.used.} = n "GetAllCurveNames"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
outNames = param.outNames
proc getActiveCurveNames*(self : UAnimInstancePtr;
curveType : EAnimCurveType;
outNames : var TArray[FName]): void {.
exportcpp: "$1_".} =
type
Params = object
curveType: EAnimCurveType
outNames: TArray[FName]
var param = Params(curveType: curveType, outNames: outNames)
let fnName {.used.} = n "GetActiveCurveNames"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
outNames = param.outNames
proc clearTransitionEvents*(self : UAnimInstancePtr;
eventName : FName): void {.
exportcpp: "$1_".} =
type
Params = object
eventName: FName
var param = Params(eventName: eventName)
let fnName {.used.} = n "ClearTransitionEvents"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc clearMorphTargets*(self : UAnimInstancePtr): void {.
exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "ClearMorphTargets"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc clearAllTransitionEvents*(self : UAnimInstancePtr): void {.
exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "ClearAllTransitionEvents"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc calculateDirection*(self : UAnimInstancePtr;
velocity : var FVector;
baseRotation : var FRotator): float32 {.
exportcpp: "$1_".} =
type
Params = object
velocity: FVector
baseRotation: FRotator
returnValue: float32
var param = Params(velocity: velocity, baseRotation: baseRotation)
let fnName {.used.} = n "CalculateDirection"
let fn {.used.} = getClassByName("AnimInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
velocity = param.velocity
baseRotation = param.baseRotation
return param.returnValue
proc keepUAnimInstance(fake : UAnimInstance) {.exportcpp.} =
discard
proc stopAnim*(self : UAnimSingleNodeInstancePtr): void {.
exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "StopAnim"
let fn {.used.} = getClassByName("AnimSingleNodeInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setReverse*(self : UAnimSingleNodeInstancePtr;
bInReverse : bool): void {.exportcpp: "$1_".} =
type
Params = object
bInReverse: bool
var param = Params(bInReverse: bInReverse)
let fnName {.used.} = n "SetReverse"
let fn {.used.} = getClassByName("AnimSingleNodeInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setPreviewCurveOverride*(self : UAnimSingleNodeInstancePtr;
poseName : var FName;
value : float32;
bRemoveIfZero : bool): void {.
exportcpp: "$1_".} =
type
Params = object
poseName: FName
value: float32
bRemoveIfZero: bool
var param = Params(poseName: poseName, value: value,
bRemoveIfZero: bRemoveIfZero)
let fnName {.used.} = n "SetPreviewCurveOverride"
let fn {.used.} = getClassByName("AnimSingleNodeInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
poseName = param.poseName
proc setPositionWithPreviousTime*(self : UAnimSingleNodeInstancePtr;
inPosition : float32;
inPreviousTime : float32;
bFireNotifies : bool = true): void {.
exportcpp: "$1_".} =
type
Params = object
inPosition: float32
inPreviousTime: float32
bFireNotifies: bool
var param = Params(inPosition: inPosition,
inPreviousTime: inPreviousTime,
bFireNotifies: bFireNotifies)
let fnName {.used.} = n "SetPositionWithPreviousTime"
let fn {.used.} = getClassByName("AnimSingleNodeInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setPosition*(self : UAnimSingleNodeInstancePtr;
inPosition : float32;
bFireNotifies : bool = true): void {.
exportcpp: "$1_".} =
type
Params = object
inPosition: float32
bFireNotifies: bool
var param = Params(inPosition: inPosition,
bFireNotifies: bFireNotifies)
let fnName {.used.} = n "SetPosition"
let fn {.used.} = getClassByName("AnimSingleNodeInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setPlayRate*(self : UAnimSingleNodeInstancePtr;
inPlayRate : float32): void {.exportcpp: "$1_".} =
type
Params = object
inPlayRate: float32
var param = Params(inPlayRate: inPlayRate)
let fnName {.used.} = n "SetPlayRate"
let fn {.used.} = getClassByName("AnimSingleNodeInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setPlaying*(self : UAnimSingleNodeInstancePtr;
bIsPlaying : bool): void {.exportcpp: "$1_".} =
type
Params = object
bIsPlaying: bool
var param = Params(bIsPlaying: bIsPlaying)
let fnName {.used.} = n "SetPlaying"
let fn {.used.} = getClassByName("AnimSingleNodeInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setMirrorDataTable*(self : UAnimSingleNodeInstancePtr;
mirrorDataTable : UMirrorDataTablePtr): void {.
exportcpp: "$1_".} =
type
Params = object
mirrorDataTable: UMirrorDataTablePtr
var param = Params(mirrorDataTable: mirrorDataTable)
let fnName {.used.} = n "SetMirrorDataTable"
let fn {.used.} = getClassByName("AnimSingleNodeInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setLooping*(self : UAnimSingleNodeInstancePtr;
bIsLooping : bool): void {.exportcpp: "$1_".} =
type
Params = object
bIsLooping: bool
var param = Params(bIsLooping: bIsLooping)
let fnName {.used.} = n "SetLooping"
let fn {.used.} = getClassByName("AnimSingleNodeInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc setBlendSpacePosition*(self : UAnimSingleNodeInstancePtr;
inPosition : var FVector): void {.
exportcpp: "$1_".} =
type
Params = object
inPosition: FVector
var param = Params(inPosition: inPosition)
let fnName {.used.} = n "SetBlendSpacePosition"
let fn {.used.} = getClassByName("AnimSingleNodeInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
inPosition = param.inPosition
proc setAnimationAsset*(self : UAnimSingleNodeInstancePtr;
newAsset : UAnimationAssetPtr;
bIsLooping : bool = true;
inPlayRate : float32 = 1.0'f32): void {.
exportcpp: "$1_".} =
type
Params = object
newAsset: UAnimationAssetPtr
bIsLooping: bool
inPlayRate: float32
var param = Params(newAsset: newAsset, bIsLooping: bIsLooping,
inPlayRate: inPlayRate)
let fnName {.used.} = n "SetAnimationAsset"
let fn {.used.} = getClassByName("AnimSingleNodeInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc playAnim*(self : UAnimSingleNodeInstancePtr;
bIsLooping : bool = false;
inPlayRate : float32 = 1.0'f32;
inStartPosition : float32 = 0.0'f32): void {.
exportcpp: "$1_".} =
type
Params = object
bIsLooping: bool
inPlayRate: float32
inStartPosition: float32
var param = Params(bIsLooping: bIsLooping, inPlayRate: inPlayRate,
inStartPosition: inStartPosition)
let fnName {.used.} = n "PlayAnim"
let fn {.used.} = getClassByName("AnimSingleNodeInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc getMirrorDataTable*(self : UAnimSingleNodeInstancePtr): UMirrorDataTablePtr {.
exportcpp: "$1_".} =
type
Params = object
returnValue: UMirrorDataTablePtr
var param = Params()
let fnName {.used.} = n "GetMirrorDataTable"
let fn {.used.} = getClassByName("AnimSingleNodeInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getLength*(self : UAnimSingleNodeInstancePtr): float32 {.
exportcpp: "$1_".} =
type
Params = object
returnValue: float32
var param = Params()
let fnName {.used.} = n "GetLength"
let fn {.used.} = getClassByName("AnimSingleNodeInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getAnimationAsset*(self : UAnimSingleNodeInstancePtr): UAnimationAssetPtr {.
exportcpp: "$1_".} =
type
Params = object
returnValue: UAnimationAssetPtr
var param = Params()
let fnName {.used.} = n "GetAnimationAsset"
let fn {.used.} = getClassByName("AnimSingleNodeInstance").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc keepUAnimSingleNodeInstance(fake : UAnimSingleNodeInstance) {.
exportcpp.} =
discard
proc `notifyColor`*(obj : UAnimNotifyPtr): var FColor {.exportcpp.} =
let prop = getClassByName("AnimNotify").getFPropertyByName(
"NotifyColor")
getPropertyValuePtr[FColor](prop, obj)[]
proc `notifyColor=`*(obj : UAnimNotifyPtr; val : FColor) =
var value : FColor = val
let prop = getClassByName("AnimNotify").getFPropertyByName(
"NotifyColor")
setPropertyValuePtr[FColor](prop, obj, value.addr)
proc `set notifyColor`*(obj : UAnimNotifyPtr; val : FColor) {.
exportcpp.} =
var value : FColor = val
let prop = getClassByName("AnimNotify").getFPropertyByName(
"NotifyColor")
setPropertyValuePtr[FColor](prop, obj, value.addr)
proc `bShouldFireInEditor`*(obj : UAnimNotifyPtr): bool {.exportcpp.} =
let prop = getClassByName("AnimNotify").getFPropertyByName(
"bShouldFireInEditor")
getValueFromBoolProp(prop, obj)
proc `bShouldFireInEditor=`*(obj : UAnimNotifyPtr; val : bool) =
var value : bool = val
let prop = getClassByName("AnimNotify").getFPropertyByName(
"bShouldFireInEditor")
setValueInBoolProp(prop, obj, value)
proc `set bShouldFireInEditor`*(obj : UAnimNotifyPtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("AnimNotify").getFPropertyByName(
"bShouldFireInEditor")
setValueInBoolProp(prop, obj, value)
proc keepUAnimNotify(fake : UAnimNotify) {.exportcpp.} =
discard
proc `notifyColor`*(obj : UAnimNotifyStatePtr): var FColor {.exportcpp.} =
let prop = getClassByName("AnimNotifyState").getFPropertyByName(
"NotifyColor")
getPropertyValuePtr[FColor](prop, obj)[]
proc `notifyColor=`*(obj : UAnimNotifyStatePtr; val : FColor) =
var value : FColor = val
let prop = getClassByName("AnimNotifyState").getFPropertyByName(
"NotifyColor")
setPropertyValuePtr[FColor](prop, obj, value.addr)
proc `set notifyColor`*(obj : UAnimNotifyStatePtr;
val : FColor) {.exportcpp.} =
var value : FColor = val
let prop = getClassByName("AnimNotifyState").getFPropertyByName(
"NotifyColor")
setPropertyValuePtr[FColor](prop, obj, value.addr)
proc `bShouldFireInEditor`*(obj : UAnimNotifyStatePtr): bool {.
exportcpp.} =
let prop = getClassByName("AnimNotifyState").getFPropertyByName(
"bShouldFireInEditor")
getValueFromBoolProp(prop, obj)
proc `bShouldFireInEditor=`*(obj : UAnimNotifyStatePtr;
val : bool) =
var value : bool = val
let prop = getClassByName("AnimNotifyState").getFPropertyByName(
"bShouldFireInEditor")
setValueInBoolProp(prop, obj, value)
proc `set bShouldFireInEditor`*(obj : UAnimNotifyStatePtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("AnimNotifyState").getFPropertyByName(
"bShouldFireInEditor")
setValueInBoolProp(prop, obj, value)
proc keepUAnimNotifyState(fake : UAnimNotifyState) {.exportcpp.} =
discard
proc keepUEngineCustomTimeStep(fake : UEngineCustomTimeStep) {.
exportcpp.} =
discard
proc getTimecode*(self : UTimecodeProviderPtr): FTimecode {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FTimecode
var param = Params()
let fnName {.used.} = n "GetTimecode"
let fn {.used.} = getClassByName("TimecodeProvider").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getSynchronizationState*(self : UTimecodeProviderPtr): ETimecodeProviderSynchronizationState {.
exportcpp: "$1_".} =
type
Params = object
returnValue: ETimecodeProviderSynchronizationState
var param = Params()
let fnName {.used.} = n "GetSynchronizationState"
let fn {.used.} = getClassByName("TimecodeProvider").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getQualifiedFrameTime*(self : UTimecodeProviderPtr): FQualifiedFrameTime {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FQualifiedFrameTime
var param = Params()
let fnName {.used.} = n "GetQualifiedFrameTime"
let fn {.used.} = getClassByName("TimecodeProvider").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getFrameRate*(self : UTimecodeProviderPtr): FFrameRate {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FFrameRate
var param = Params()
let fnName {.used.} = n "GetFrameRate"
let fn {.used.} = getClassByName("TimecodeProvider").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getDelayedTimecode*(self : UTimecodeProviderPtr): FTimecode {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FTimecode
var param = Params()
let fnName {.used.} = n "GetDelayedTimecode"
let fn {.used.} = getClassByName("TimecodeProvider").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc getDelayedQualifiedFrameTime*(self : UTimecodeProviderPtr): FQualifiedFrameTime {.
exportcpp: "$1_".} =
type
Params = object
returnValue: FQualifiedFrameTime
var param = Params()
let fnName {.used.} = n "GetDelayedQualifiedFrameTime"
let fn {.used.} = getClassByName("TimecodeProvider").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
return param.returnValue
proc fetchTimecode*(self : UTimecodeProviderPtr;
outFrameTime : var FQualifiedFrameTime): bool {.
exportcpp: "$1_".} =
type
Params = object
outFrameTime: FQualifiedFrameTime
returnValue: bool
var param = Params(outFrameTime: outFrameTime)
let fnName {.used.} = n "FetchTimecode"
let fn {.used.} = getClassByName("TimecodeProvider").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
outFrameTime = param.outFrameTime
return param.returnValue
proc fetchAndUpdate*(self : UTimecodeProviderPtr): void {.
exportcpp: "$1_".} =
type
Params = object
var param = Params()
let fnName {.used.} = n "FetchAndUpdate"
let fn {.used.} = getClassByName("TimecodeProvider").findFunctionByName(
fnName)
self.processEvent(fn, param.addr)
proc keepUTimecodeProvider(fake : UTimecodeProvider) {.exportcpp.} =
discard
proc `soundClassObject`*(obj : USoundBasePtr): USoundClassPtr {.
exportcpp.} =
let prop = getClassByName("SoundBase").getFPropertyByName(
"SoundClassObject")
getPropertyValuePtr[USoundClassPtr](prop, obj)[]
proc `soundClassObject=`*(obj : USoundBasePtr;
val : USoundClassPtr) =
var value : USoundClassPtr = val
let prop = getClassByName("SoundBase").getFPropertyByName(
"SoundClassObject")
setPropertyValuePtr[USoundClassPtr](prop, obj, value.addr)
proc `set soundClassObject`*(obj : USoundBasePtr;
val : USoundClassPtr) {.exportcpp.} =
var value : USoundClassPtr = val
let prop = getClassByName("SoundBase").getFPropertyByName(
"SoundClassObject")
setPropertyValuePtr[USoundClassPtr](prop, obj, value.addr)
proc `bOverrideConcurrency`*(obj : USoundBasePtr): bool {.exportcpp.} =
let prop = getClassByName("SoundBase").getFPropertyByName(
"bOverrideConcurrency")
getValueFromBoolProp(prop, obj)
proc `bOverrideConcurrency=`*(obj : USoundBasePtr; val : bool) =
var value : bool = val
let prop = getClassByName("SoundBase").getFPropertyByName(
"bOverrideConcurrency")
setValueInBoolProp(prop, obj, value)
proc `set bOverrideConcurrency`*(obj : USoundBasePtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SoundBase").getFPropertyByName(
"bOverrideConcurrency")
setValueInBoolProp(prop, obj, value)
proc `bEnableBusSends`*(obj : USoundBasePtr): bool {.exportcpp.} =
let prop = getClassByName("SoundBase").getFPropertyByName(
"bEnableBusSends")
getValueFromBoolProp(prop, obj)
proc `bEnableBusSends=`*(obj : USoundBasePtr; val : bool) =
var value : bool = val
let prop = getClassByName("SoundBase").getFPropertyByName(
"bEnableBusSends")
setValueInBoolProp(prop, obj, value)
proc `set bEnableBusSends`*(obj : USoundBasePtr; val : bool) {.
exportcpp.} =
var value : bool = val
let prop = getClassByName("SoundBase").getFPropertyByName(
"bEnableBusSends")
setValueInBoolProp(prop, obj, value)
proc `bBypassVolumeScaleForPriority`*(obj : USoundBasePtr): bool {.
exportcpp.} =
let prop = getClassByName("SoundBase").getFPropertyByName(
"bBypassVolumeScaleForPriority")
getValueFromBoolProp(prop, obj)
proc `bBypassVolumeScaleForPriority=`*(obj : USoundBasePtr;
val : bool) =
var value : bool = val
let prop = getClassByName("SoundBase").getFPropertyByName(
"bBypassVolumeScaleForPriority")
setValueInBoolProp(prop, obj, value)
proc `set bBypassVolumeScaleForPriority`*(obj : USoundBasePtr;
val : bool) {.exportcpp.} =
var value : bool = val
let prop = getClassByName("SoundBase").getFPropertyByName(
"bBypassVolumeScaleForPriority")
setValueInBoolProp(prop, obj, value)
proc `virtualizationMode`*(obj : USoundBasePtr): EVirtualizationMode {.
exportcpp.} =
let prop = getClassByName("SoundBase").getFPropertyByName(
"VirtualizationMode")
getPropertyValuePtr[EVirtualizationMode](prop, obj)[]
proc `virtualizationMode=`*(obj : USoundBasePtr;
val : EVirtualizationMode) =
var value : EVirtualizationMode = val
let prop = getClassByName("SoundBase").getFPropertyByName(
"VirtualizationMode")
setPropertyValuePtr[EVirtualizationMode](prop, obj, value.addr)
proc `set virtualizationMode`*(obj : USoundBasePtr;
val : EVirtualizationMode) {.exportcpp.} =
var value : EVirtualizationMode = val
let prop = getClassByName("SoundBase").getFPropertyByName(
"VirtualizationMode")
setPropertyValuePtr[EVirtualizationMode](prop, obj, value.addr)
proc `concurrencySet`*(obj : USoundBasePtr): TSet[USoundConcurrencyPtr] {.
exportcpp.} =
let prop = getClassByName("SoundBase").getFPropertyByName(
"ConcurrencySet")
getPropertyValuePtr[TSet[USoundConcurrencyPtr]](prop, obj)[]
proc `concurrencySet=`*(obj : USoundBasePtr;
val : TSet[USoundConcurrencyPtr]) =
var value : TSet[USoundConcurrencyPtr] = val
let prop = getClassByName("SoundBase").getFPropertyByName(
"ConcurrencySet")
setPropertyValuePtr[TSet[USoundConcurrencyPtr]](pr
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment