code: LANDSCAPEPATCH_API const [FTypeLayoutDesc](API\Runtime\Core\Serialization\FTypeLayoutDesc) & GetTypeLayout() const


className: InterfaceType

module: LandscapePatch

code: static constexpr [ETypeLayoutInterface::Type](API\Runtime\Core\Serialization\ETypeLayoutInterface__Type) InterfaceType = ETypeLayoutInterface:: NonVirtual;


code: static void Initialize &40; FTypeLayoutDesc & TypeDesc &41;


className: InternalLinkType

code: template<int Counter> struct InternalLinkType


code: static void ModifyCompilationEnvironmentImpl ( const [FShaderPermutationParameters](API\Runtime\RenderCore\FShaderPermutationParameters) & Parameters, [FShaderCompilerEnvironment](API\Runtime\RenderCore\FShaderCompilerEnvironment) & OutEnvironment )


code: static void ModifyCompilationEnvironment ( const [FGlobalShaderPermutationParameters](API\Runtime\RenderCore\FGlobalShaderPermutationParamete-) & InParameters, [FShaderCompilerEnvironment](API\Runtime\RenderCore\FShaderCompilerEnvironment) & OutEnvironment )


code: static bool ShouldCompilePermutationImpl ( const [FShaderPermutationParameters](API\Runtime\RenderCore\FShaderPermutationParameters) & Parameters )


code: static bool ShouldCompilePermutation ( const [FGlobalShaderPermutationParameters](API\Runtime\RenderCore\FGlobalShaderPermutationParamete-) & Parameters )


code: static LANDSCAPEPATCH_API [FTypeLayoutDesc](API\Runtime\Core\Serialization\FTypeLayoutDesc) & StaticGetTypeLayout()


code: FReinitializeLandscapePatchPS()


code: FReinitializeLandscapePatchPS ( const [ShaderMetaType::CompiledShaderInitializerType](API\Runtime\RenderCore\FGlobalShaderType\CompiledShaderInitializerType) & Initializer )


className: FReinitializeLandscapePatchPS

code: class FReinitializeLandscapePatchPS : public [FGlobalShader](API\Runtime\RenderCore\FGlobalShader)


code: static void AddToRenderGraph ( [FRDGBuilder](API\Runtime\RenderCore\FRDGBuilder) & GraphBuilder, FRDGTextureRef SourceTexture, FRDGTextureRef DestinationTexture )


code: static [FShader](API\Runtime\RenderCore\FShader) * ConstructCompiledInstance ( const typename [FShader::CompiledShaderInitializerType](API\Runtime\RenderCore\FShader\CompiledShaderInitializerType) & Initializer )


className: CounterBase

code: static constexpr int CounterBase = __COUNTER__;


code: static [FShader](API\Runtime\RenderCore\FShader) * ConstructSerializedInstance()


code: static FUniformBufferRHIRef CreateUniformBuffer &40; const FParameters & InContents, EUniformBufferUsage InUsage &41;


className: Alignment

code: static Alignment = 16;


className: bIsStoredInConstantBuffer

code: static bIsStoredInConstantBuffer = true;


className: FileName

code: static FileName = builtin_FILE();


className: FileLine

code: static FileLine = builtin_LINE();


code: static const FShaderParametersMetadata &42; GetStructMetadata&40;&41;


className: NumColumns

code: static NumColumns = 1;


className: NumElements

code: static NumElements = 0;


className: NumRows

code: static NumRows = 1;


className: TAlignedType

code: typedef FParameters TAlignedType


className: FTypeInfo

description: GetStructMetadata()

code: struct FTypeInfo


className: zzFuncPtr

code: typedef void &42; zzFuncPtr


code: static TArray< FShaderParametersMetadata::FMember > zzGetMembers&40;&41;


className: zzMemberFunc

code: typedef zzFuncPtr(&42; zzMemberFunc


className: zzMemberIdInDestinationResolution


className: zzTThisStruct

code: typedef FParameters zzTThisStruct


code: static const [FShaderParametersMetadata](API\Runtime\RenderCore\FShaderParametersMetadata) * GetRootParametersMetadata()


code: static LANDSCAPEPATCH_API [ShaderMetaType](API\Runtime\RenderCore\FGlobalShader\ShaderMetaType) & GetStaticType()


code: LANDSCAPEPATCH_API const [FTypeLayoutDesc](API\Runtime\Core\Serialization\FTypeLayoutDesc) & GetTypeLayout() const


className: FParameters

code: class FParameters

InDestinationResolution

type: TShaderParamete...

InSource

type: TShaderResource...

RenderTargets

type: FRenderTargetBi...


className: InterfaceType

code: static constexpr [ETypeLayoutInterface::Type](API\Runtime\Core\Serialization\ETypeLayoutInterface__Type) InterfaceType = ETypeLayoutInterface:: NonVirtual;


className: InternalBaseType

code: typedef typename [TGetBaseTypeHelper](API\Runtime\Core\Serialization\TGetBaseTypeHelper)< [FSimpleTextureCopyPS](API\Plugins\LandscapePatch\FSimpleTextureCopyPS) >::Type InternalBaseType


code: static void Initialize &40; FTypeLayoutDesc & TypeDesc &41;


className: InternalLinkType

code: template<int Counter> struct InternalLinkType


code: static void ModifyCompilationEnvironment ( const [FGlobalShaderPermutationParameters](API\Runtime\RenderCore\FGlobalShaderPermutationParamete-) & InParameters, [FShaderCompilerEnvironment](API\Runtime\RenderCore\FShaderCompilerEnvironment) & OutEnvironment )


code: static void ModifyCompilationEnvironmentImpl ( const [FShaderPermutationParameters](API\Runtime\RenderCore\FShaderPermutationParameters) & Parameters, [FShaderCompilerEnvironment](API\Runtime\RenderCore\FShaderCompilerEnvironment) & OutEnvironment )


code: static bool ShouldCompilePermutation ( const [FGlobalShaderPermutationParameters](API\Runtime\RenderCore\FGlobalShaderPermutationParamete-) & Parameters )


code: static bool ShouldCompilePermutationImpl ( const [FShaderPermutationParameters](API\Runtime\RenderCore\FShaderPermutationParameters) & Parameters )


code: static LANDSCAPEPATCH_API [FTypeLayoutDesc](API\Runtime\Core\Serialization\FTypeLayoutDesc) & StaticGetTypeLayout()


code: FSimpleTextureCopyPS ( const [ShaderMetaType::CompiledShaderInitializerType](API\Runtime\RenderCore\FGlobalShaderType\CompiledShaderInitializerType) & Initializer )


className: FSimpleTextureCopyPS

description: Simple shader for copying textures of potentially different resolutions.

code: class FSimpleTextureCopyPS : public [FGlobalShader](API\Runtime\RenderCore\FGlobalShader)


code: namespace UE { namespace Landscape { [FApplyLandscapeTextureHeightPatchPS::EFlags](API\Plugins\LandscapePatch\FApplyLandscapeTextureHeightPatc-\EFlags) & UE::Landscape::operator&= ( [FApplyLandscapeTextureHeightPatchPS::EFlags](API\Plugins\LandscapePatch\FApplyLandscapeTextureHeightPatc-\EFlags) & Lhs, [FApplyLandscapeTextureHeightPatchPS::EFlags](API\Plugins\LandscapePatch\FApplyLandscapeTextureHeightPatc-\EFlags) Rhs ) } }


code: namespace UE { namespace Landscape { [FApplyLandscapeTextureWeightPatchPS::EFlags](API\Plugins\LandscapePatch\FApplyLandscapeTextureWeightPatc-\EFlags) & UE::Landscape::operator&= ( [FApplyLandscapeTextureWeightPatchPS::EFlags](API\Plugins\LandscapePatch\FApplyLandscapeTextureWeightPatc-\EFlags) & Lhs, [FApplyLandscapeTextureWeightPatchPS::EFlags](API\Plugins\LandscapePatch\FApplyLandscapeTextureWeightPatc-\EFlags) Rhs ) } }


code: namespace UE { namespace Landscape { [FApplyLandscapeTextureHeightPatchPS::EFlags](API\Plugins\LandscapePatch\FApplyLandscapeTextureHeightPatc-\EFlags) & UE::Landscape::operator^= ( [FApplyLandscapeTextureHeightPatchPS::EFlags](API\Plugins\LandscapePatch\FApplyLandscapeTextureHeightPatc-\EFlags) & Lhs, [FApplyLandscapeTextureHeightPatchPS::EFlags](API\Plugins\LandscapePatch\FApplyLandscapeTextureHeightPatc-\EFlags) Rhs ) } }


code: namespace UE { namespace Landscape { [FApplyLandscapeTextureWeightPatchPS::EFlags](API\Plugins\LandscapePatch\FApplyLandscapeTextureWeightPatc-\EFlags) & UE::Landscape::operator^= ( [FApplyLandscapeTextureWeightPatchPS::EFlags](API\Plugins\LandscapePatch\FApplyLandscapeTextureWeightPatc-\EFlags) & Lhs, [FApplyLandscapeTextureWeightPatchPS::EFlags](API\Plugins\LandscapePatch\FApplyLandscapeTextureWeightPatc-\EFlags) Rhs ) } }


code: namespace UE { namespace Landscape { constexpr [FApplyLandscapeTextureHeightPatchPS::EFlags](API\Plugins\LandscapePatch\FApplyLandscapeTextureHeightPatc-\EFlags) UE::Landscape::operator& ( [FApplyLandscapeTextureHeightPatchPS::EFlags](API\Plugins\LandscapePatch\FApplyLandscapeTextureHeightPatc-\EFlags) Lhs, [FApplyLandscapeTextureHeightPatchPS::EFlags](API\Plugins\LandscapePatch\FApplyLandscapeTextureHeightPatc-\EFlags) Rhs ) } }


code: namespace UE { namespace Landscape { constexpr [FApplyLandscapeTextureWeightPatchPS::EFlags](API\Plugins\LandscapePatch\FApplyLandscapeTextureWeightPatc-\EFlags) UE::Landscape::operator& ( [FApplyLandscapeTextureWeightPatchPS::EFlags](API\Plugins\LandscapePatch\FApplyLandscapeTextureWeightPatc-\EFlags) Lhs, [FApplyLandscapeTextureWeightPatchPS::EFlags](API\Plugins\LandscapePatch\FApplyLandscapeTextureWeightPatc-\EFlags) Rhs ) } }


code: namespace UE { namespace Landscape { constexpr [FApplyLandscapeTextureHeightPatchPS::EFlags](API\Plugins\LandscapePatch\FApplyLandscapeTextureHeightPatc-\EFlags) UE::Landscape::operator^ ( [FApplyLandscapeTextureHeightPatchPS::EFlags](API\Plugins\LandscapePatch\FApplyLandscapeTextureHeightPatc-\EFlags) Lhs, [FApplyLandscapeTextureHeightPatchPS::EFlags](API\Plugins\LandscapePatch\FApplyLandscapeTextureHeightPatc-\EFlags) Rhs ) } }


code: namespace UE { namespace Landscape { constexpr [FApplyLandscapeTextureWeightPatchPS::EFlags](API\Plugins\LandscapePatch\FApplyLandscapeTextureWeightPatc-\EFlags) UE::Landscape::operator^ ( [FApplyLandscapeTextureWeightPatchPS::EFlags](API\Plugins\LandscapePatch\FApplyLandscapeTextureWeightPatc-\EFlags) Lhs, [FApplyLandscapeTextureWeightPatchPS::EFlags](API\Plugins\LandscapePatch\FApplyLandscapeTextureWeightPatc-\EFlags) Rhs ) } }


code: namespace UE { namespace Landscape { constexpr bool UE::Landscape::operator! ( [FApplyLandscapeTextureHeightPatchPS::EFlags](API\Plugins\LandscapePatch\FApplyLandscapeTextureHeightPatc-\EFlags) E ) } }


code: namespace UE { namespace Landscape { constexpr bool UE::Landscape::operator! ( [FApplyLandscapeTextureWeightPatchPS::EFlags](API\Plugins\LandscapePatch\FApplyLandscapeTextureWeightPatc-\EFlags) E ) } }


code: namespace UE { namespace Landscape { constexpr [FApplyLandscapeTextureHeightPatchPS::EFlags](API\Plugins\LandscapePatch\FApplyLandscapeTextureHeightPatc-\EFlags) UE::Landscape::operator~ ( [FApplyLandscapeTextureHeightPatchPS::EFlags](API\Plugins\LandscapePatch\FApplyLandscapeTextureHeightPatc-\EFlags) E ) } }


code: namespace UE { namespace Landscape { constexpr [FApplyLandscapeTextureWeightPatchPS::EFlags](API\Plugins\LandscapePatch\FApplyLandscapeTextureWeightPatc-\EFlags) UE::Landscape::operator~ ( [FApplyLandscapeTextureWeightPatchPS::EFlags](API\Plugins\LandscapePatch\FApplyLandscapeTextureWeightPatc-\EFlags) E ) } }


code: namespace UE { namespace Landscape { namespace PatchUtil { void UE::Landscape::PatchUtil::CopyTextureOnRenderThread ( [FRHICommandListImmediate](API\Runtime\RHI\FRHICommandListImmediate) & RHICmdList, const [FTextureResource](API\Runtime\Engine\FTextureResource) & Source, [FTextureResource](API\Runtime\Engine\FTextureResource) & Destination ) } } }


code: virtual bool AffectsVisibilityLayer() const


description: TODO: For now the height patches have a similar interface to blueprint brushes, but this is likely to change. We are likely to pass a graph builder to the patches instead, along with an area that we want affected.

code: virtual void Initialize_Native ( const FTransform & InLandscapeTransform, const FIntPoint & InLandscapeSize, const FIntPoint & InLandscapeRenderTargetSize )


description: UActorComponent.

code: virtual void OnComponentCreated()


code: virtual [UTextureRenderTarget2D](API\Runtime\Engine\Engine\UTextureRenderTarget2D) * RenderLayer_Native ( const [FLandscapeBrushParameters](API\Runtime\Landscape\FLandscapeBrushParameters) & InParameters )


className: ULandscapeCircleHeightPatch

description: The simplest height patch: a circle of flat ground with a falloff past the initial radius across which the alpha decreases linearly. When added to an actor, initializes itself to the bottom of the bounding box.

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(Blueprintable, BlueprintType, ClassGroup=Landscape, Meta=(BlueprintSpawnableComponent)) class ULandscapeCircleHeightPatch : public [ULandscapePatchComponent](API\Plugins\LandscapePatch\ULandscapePatchComponent)

bEditVisibility

type: bool

description: Specifies if this patch edits the visibility layer.

bExclusiveRadius

description: When true, only the vertices in the circle have alpha 1.

Falloff

type: float

description: Distance across which the alpha will go from 1 down to 0 outside of circle.


code: virtual void CopyToInternalTexture()


code: virtual void SetFormat ( ETextureRenderTargetFormat FormatToUse )


ConversionParams

type: FLandscapeHeigh...

RenderTargetFormat

type: TEnumAsByte< ET...


code: virtual bool AffectsWeightmapLayer ( const [FName](API\Runtime\Core\UObject\FName) & InLayerName ) const


code: void ApplyComponentInstanceData ( struct [FLandscapePatchComponentInstanceData](API\Plugins\LandscapePatch\FLandscapePatchComponentInstance-) * ComponentInstanceData )


description: Add properties to the component owner's actor desc.

code: virtual void GetActorDescProperties ( [FPropertyPairsMap](API\Runtime\Engine\FPropertyPairsMap) & PropertyPairsMap ) const


description: Called before we throw away components during RerunConstructionScripts, to cache any data we wish to persist across that operation

code: virtual [TStructOnScope](API\Runtime\CoreUObject\UObject\TStructOnScope)< [FActorComponentInstanceData](API\Runtime\Engine\FActorComponentInstanceData) > GetComponentInstanceData() const


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="LandscapePatch") virtual [ALandscapePatchManager](API\Plugins\LandscapePatch\ALandscapePatchManager) * GetPatchManager() const


description: Deprecated* Use AffectsWeightmapLayer

code: virtual bool IsAffectingWeightmapLayer ( const [FName](API\Runtime\Core\UObject\FName) & InLayerName ) const


description: Returns whether this component is an editor-only object or not

code: virtual bool IsEditorOnly() const


description: false if the patch is marked as disabled and therefore can't affect the landscape.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="LandscapePatch") virtual bool IsEnabled() const


description:
Called during async load to determine if PostLoad can be called on the loading thread.
true if this object's PostLoad is thread safe

code: virtual bool IsPostLoadThreadSafe() const


description: Move the patch to be the last processed patch in the current patch manager. This is a way to reorder patches relative to each other.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(CallInEditor, Category=Initialization) void MoveToTop()


description:
Called during saving to determine the load flags to save with the object. If false, this object will be discarded on clients
true if this object should be loaded on clients

code: virtual bool NeedsLoadForClient() const


description:
Called during saving to determine the load flags to save with the object. If false, this object will be discarded on servers
true if this object should be loaded on servers

code: virtual bool NeedsLoadForServer() const


description: UActorComponent.

code: virtual void OnComponentCreated()


description: Called when a component is destroyed

code: virtual void OnComponentDestroyed ( bool bDestroyingHierarchy )


description: Called when a component is registered, after Scene is set, but before CreateRenderState_Concurrent or OnCreatePhysicsState are called.

code: virtual void OnRegister()


description: For now we keep the patches largely editor-only, since we don't yet support runtime landscape editing. The above functions are also editor-only (and don't work at runtime), but can't be in WITH_EDITOR blocks so that they can be called from non-editor-only classes in editor contexts.

code: virtual void OnUpdateTransform ( EUpdateTransformFlags UpdateTransformFlags, ETeleportType Teleport )


description: UObject.

code: virtual void PostEditChangeProperty ( [FPropertyChangedEvent](API\Runtime\CoreUObject\UObject\FPropertyChangedEvent) & PropertyChangedEvent )


description: Do any object-specific cleanup required immediately after loading an object. This is not called for newly-created objects, and by default will always execute on the game thread.

code: virtual void PostLoad()


code: virtual [UTextureRenderTarget2D](API\Runtime\Engine\Engine\UTextureRenderTarget2D) * RenderLayer_Native ( const [FLandscapeBrushParameters](API\Runtime\Landscape\FLandscapeBrushParameters) & InParameters )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="LandscapePatch") void RequestLandscapeUpdate ( bool bInUserTriggeredUpdate )


description: Allows the patch to be disabled, so that it no longer affects the landscape. This can be useful when deleting the patch is undesirable, usually when the disabling is temporary.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="LandscapePatch") void SetIsEnabled ( bool bEnabledIn )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="LandscapePatch") virtual void SetLandscape ( [ALandscape](API\Runtime\Landscape\ALandscape) * NewLandscape )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="LandscapePatch") virtual void SetPatchManager ( [ALandscapePatchManager](API\Plugins\LandscapePatch\ALandscapePatchManager) * NewPatchManager )


code: ULandscapePatchComponent ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


className: ULandscapePatchComponent

description: Base class for landscape patches: components that can be attached to meshes and moved around to make the meshes affect the landscape around themselves.

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(Blueprintable, BlueprintType, Abstract) class ULandscapePatchComponent : public [USceneComponent](API\Runtime\Engine\Components\USceneComponent)

bIsEnabled

description: When false, patch does not affect the landscape. Useful for temporarily disabling the patch.

bLoadedButNotYetRegistered

description: This is true for existing height patches right after they are loaded, so that we can ignore the first OnRegister call.

bWasCopy

description: Determines whether the height patch was made by copying a different height patch.

Landscape

type: TSoftObjectPtr<...


description: ImportCustomProperties()

code: virtual void ExportCustomProperties ( [FOutputDevice](API\Runtime\Core\Misc\FOutputDevice) & Out, uint32 Indent )


code: virtual [UTexture2D](API\Runtime\Engine\Engine\UTexture2D) * GetInternalTexture()


code: virtual [UTextureRenderTarget2D](API\Runtime\Engine\Engine\UTextureRenderTarget2D) * GetRenderTarget()


description: Allows us to disable copying back and forth between render target and texture when this is not possible (for instance, when rendering is turned off, so render target resources are not allocated).


description: Called after importing property values for this object (paste, duplicate or .t3d import) Allow the object to perform any cleanup for properties which shouldn't be duplicated or are unsupported by the script serialization

code: virtual void PostEditImport()


description: FObjectDuplicationParameters

code: virtual void PreDuplicate ( [FObjectDuplicationParameters](API\Runtime\CoreUObject\UObject\FObjectDuplicationParameters) & DupParams )


code: virtual void SetUseInternalTextureOnly ( bool bUseInternalTextureOnlyIn, bool bCopyExisting )


code: virtual void SetResolution ( int32 SizeXIn, int32 SizeYIn )


className: ULandscapeTextureBackedRenderTargetBase

description: After anInitialize()call, the internal texture will always be present, and the render target will be present depending on how SetUseInternalTextureOnly is called (by default, present).

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(Abstract) class ULandscapeTextureBackedRenderTargetBase : public [UObject](API\Runtime\CoreUObject\UObject\UObject)

InternalTexture

type: TObjectPtr<UTe...


description: Bydefault, the layer is added with source mode set to be a texture-backed render target.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=LandscapePatch) virtual void AddWeightPatch ( const [FName](API\Runtime\Core\UObject\FName) & InWeightmapLayerName, [ELandscapeTexturePatchSourceMode](API\Plugins\LandscapePatch\ELandscapeTexturePatchSourceMode) SourceMode, bool bUseAlphaChannel )


code: virtual bool AffectsVisibilityLayer() const


code: virtual bool AffectsWeightmapLayer ( const [FName](API\Runtime\Core\UObject\FName) & InLayerName ) const


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=LandscapePatch) virtual void ClearWeightPatchBlendModeOverride ( const [FName](API\Runtime\Core\UObject\FName) & InWeightmapLayerName )


description: Sets the soure mode of all weight patches to "None".

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=LandscapePatch) virtual void DisableAllWeightPatches()


description: Gives size in unscaled world coordinates of the patch in the world, based off of UnscaledCoverage and texture resolution (i.e., adds a half-pixel around UnscaledCoverage).

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=LandscapePatch) virtual FVector2D GetFullUnscaledWorldSize() const


description: These need to be public so that we can take the internal textures and write them to external ones, but unclear whether we want to expose them to blueprints, since this is a fairly internal thing.


description: In addition, you may need to call SetHeightEncodingMode, SetHeightEncodingSettings, and SetZeroHeightMeaning based on how you want the data you write to be interpreted. This part is not specific to using an internal render target, since you are likely to need to do that with a TextureAsset source mode as well.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=LandscapePatch) virtual [UTextureRenderTarget2D](API\Runtime\Engine\Engine\UTextureRenderTarget2D) * GetHeightRenderTarget ( bool bMarkDirty )


description:
Given the landscape resolution, current patch coverage, and a landscape resolution multiplier, gives the needed resolution of the landscape patch. I.e., figures out the number of pixels in the landcape that would be in a region of such size, and then uses the resolution multiplier to give a result.
true if successful (may fail if landscape is not set, for instance)

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=LandscapePatch, Meta=(ResolutionMultiplier="1.0")) virtual bool GetInitResolutionFromLandscape ( float ResolutionMultiplier, FVector2D & ResolutionOut ) const


description: Gets the transform from patch to world. The transform is based off of the component transform, but with rotation changed to align to the landscape, only using the yaw to rotate it relative to the landscape.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=LandscapePatch) virtual FTransform GetPatchToWorldTransform() const


description: Gets the size (in pixels) of the internal textures used by the patch. Does not reflect the resolution of any used texture assets (if the source mode is texture asset).

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=LandscapePatch) virtual FVector2D GetResolution() const


description: Gives size in unscaled world coordinates (ie before applying patch transform) of the patch as measured between the centers of the outermost pixels. Measuring the coverage this way means that a patch can affect the same region of the landscape regardless of patch resolution. This is also the range across which bilinear interpolation always has correct values, so the area outside this center portion is usually set as a "dead" border that doesn't affect the landscape.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=LandscapePatch) virtual FVector2D GetUnscaledCoverage() const


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=LandscapePatch) virtual [UTextureRenderTarget2D](API\Runtime\Engine\Engine\UTextureRenderTarget2D) * GetWeightPatchRenderTarget ( const [FName](API\Runtime\Core\UObject\FName) & InWeightmapLayerName )


code: [UTexture2D](API\Runtime\Engine\Engine\UTexture2D) * GetWeightPatchInternalTexture ( const [FName](API\Runtime\Core\UObject\FName) & InWeightmapLayerName )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=LandscapePatch) virtual [ELandscapeTexturePatchSourceMode](API\Plugins\LandscapePatch\ELandscapeTexturePatchSourceMode) GetWeightPatchSourceMode ( const [FName](API\Runtime\Core\UObject\FName) & InWeightmapLayerName )


description: ULandscapePatchComponent

code: virtual bool IsAffectingWeightmapLayer ( const [FName](API\Runtime\Core\UObject\FName) & InLayerName ) const


description: UObject.

code: virtual void PostEditChangeProperty ( [FPropertyChangedEvent](API\Runtime\CoreUObject\UObject\FPropertyChangedEvent) & PropertyChangedEvent )


description: false if the patch is marked as disabled and therefore can't affect the landscape.

code: virtual bool IsEnabled() const


description: Given the current initialization settings, reinitialize the height patch.


code: void ReinitializeHeight &40; UTextureRenderTarget2D &42; InCombinedResult &41;


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=LandscapePatch) virtual void RemoveAllWeightPatches()


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=LandscapePatch) virtual void RemoveWeightPatch ( const [FName](API\Runtime\Core\UObject\FName) & InWeightmapLayerName )


description: Just like SetSourceEncodingMode, but resets ZeroInEncoding, WorldSpaceEncodingScale, and height render target format to mode-specific defaults.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=LandscapePatch) void ResetHeightEncodingMode ( [ELandscapeTextureHeightPatchEncoding](API\Plugins\LandscapePatch\ELandscapeTextureHeightPatchEnco-) EncodingMode )


code: virtual [UTextureRenderTarget2D](API\Runtime\Engine\Engine\UTextureRenderTarget2D) * RenderLayer_Native ( const [FLandscapeBrushParameters](API\Runtime\Landscape\FLandscapeBrushParameters) & InParameters )


description: Determines how the height patch is blended into the existing terrain.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=LandscapePatch) void SetBlendMode ( [ELandscapeTexturePatchBlendMode](API\Plugins\LandscapePatch\ELandscapeTexturePatchBlendMode) BlendModeIn )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=LandscapePatch) virtual void SetEditVisibilityLayer ( const [FName](API\Runtime\Core\UObject\FName) & InWeightmapLayerName, const bool bEditVisibilityLayer )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=LandscapePatch) void SetFalloff ( float FalloffIn )


description: Set settings that determine how values in the patch are translated into heights. This is only used if the encoding mode is not NativePackedHeight, where values are expected to be already in the same space as the landscape heightmap.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=LandscapePatch) void SetHeightEncodingSettings ( const [FLandscapeTexturePatchEncodingSettings](API\Plugins\LandscapePatch\FLandscapeTexturePatchEncodingSe-) & Settings )


description: Set the height encoding mode for the patch, which determines how stored values in the patch are translated into heights when applying to landscape.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=LandscapePatch) void SetHeightEncodingMode ( [ELandscapeTextureHeightPatchEncoding](API\Plugins\LandscapePatch\ELandscapeTextureHeightPatchEnco-) EncodingMode )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=LandscapePatch, Meta=(ETextureRenderTargetFormat="ETextureRenderTargetFormat::RTF_R32f")) void SetHeightRenderTargetFormat ( ETextureRenderTargetFormat Format )


description: Changes source mode. When changing between sources, existing data is copied from one to the other when possible.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=LandscapePatch) virtual void SetHeightSourceMode ( [ELandscapeTexturePatchSourceMode](API\Plugins\LandscapePatch\ELandscapeTexturePatchSourceMode) NewMode )


description: Sets the texture used for height when the height source mode is set to texture asset. Note that virtual textures are not supported.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=LandscapePatch) void SetHeightTextureAsset ( [UTexture](API\Runtime\Engine\Engine\UTexture) * TextureIn )


description:
Sets the resolution of the currently used internal texture or render target. Has no effect if the source mode is set to an external texture asset.
true if successful.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=LandscapePatch) virtual void SetResolution ( FVector2D ResolutionIn )


description: Set the patch coverage (see GetUnscaledCoverage for description).

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=LandscapePatch) virtual void SetUnscaledCoverage ( FVector2D Coverage )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=LandscapePatch) virtual void SetUseAlphaChannelForWeightPatch ( const [FName](API\Runtime\Core\UObject\FName) & InWeightmapLayerName, bool bUseAlphaChannel )


description: Determines whether the height patch alpha channel is used for blending into the existing values. Note that the source data needs to have an alpha channel in this case. How the alpha channel is used depends on the patch blend mode (see SetBlendMode).

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="LandscapePatch") void SetUseAlphaChannelForHeight ( bool bUse )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=LandscapePatch) virtual void SetWeightPatchBlendModeOverride ( const [FName](API\Runtime\Core\UObject\FName) & InWeightmapLayerName, [ELandscapeTexturePatchBlendMode](API\Plugins\LandscapePatch\ELandscapeTexturePatchBlendMode) BlendMode )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=LandscapePatch) virtual void SetWeightPatchSourceMode ( const [FName](API\Runtime\Core\UObject\FName) & InWeightmapLayerName, [ELandscapeTexturePatchSourceMode](API\Plugins\LandscapePatch\ELandscapeTexturePatchSourceMode) NewMode )


code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category=LandscapePatch) void SetWeightPatchTextureAsset ( const [FName](API\Runtime\Core\UObject\FName) & InWeightmapLayerName, [UTexture](API\Runtime\Engine\Engine\UTexture) * TextureIn )


description: Set how zero height is interpreted, see comments in ELandscapeTextureHeightPatchZeroHeightMeaning.

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, Category="LandscapePatch") void SetZeroHeightMeaning ( [ELandscapeTextureHeightPatchZeroHeightMeaning](API\Plugins\LandscapePatch\ELandscapeTextureHeightPatchZero-) ZeroHeightMeaningIn )


description: Adjusts patch rotation to be aligned to a 90 degree increment relative to the landscape, adjusts UnscaledPatchCoverage such that it becomes a multiple of landscape quad size, and adjusts patch location so that the boundaries of the covered area lie on the nearest landscape vertices. Note that this doesn't adjust the resolution of the texture that the patch uses, so landscape vertices within the inside of the patch may still not always align with texture patch pixel centers (if the resolutions aren't multiples of each other).

code: [UFUNCTION](Programming/UnrealArchitecture/Reference/Functions)(BlueprintCallable, CallInEditor, Category=Initialization) void SnapToLandscape()


className: ULandscapeTexturePatch

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)(Blueprintable, BlueprintType, ClassGroup=Landscape, Meta=(BlueprintSpawnableComponent)) class ULandscapeTexturePatch : public [ULandscapePatchComponent](API\Plugins\LandscapePatch\ULandscapePatchComponent)

bApplyComponentZScale

description: Whether to apply the patch Z scale to the height stored in the patch.

bBaseResolutionOffLandscape

description: When initializing from landscape, set resolution based off of the landscape (and a multiplier).

BlendMode

type: ELandscapeTextu...

bUseTextureAlphaForHeight

description: When true, texture alpha channel will be used when applying the patch.

ClampMin

description: Texture width to use when reinitializing, if not basing resolution off landscape.

DetailPanelHeightSourceMode

description: How the heightmap of the patch is stored.

EditCondition

description: Texture used when source mode is set to a texture asset.

Falloff

description: Distance (in unscaled world coordinates) across which to smoothly fall off the patch effects.

HeightInternalData

type: TObjectPtr<ULa...

description: Not directly settable via detail panel- for display/debugging purposes only.

NumWeightPatches

description: Used to detect changes to the number of weight patches via the detail panel, so that we can initialize the "owner" pointer when patches are added or trigger update when patches are removed.

UnscaledPatchCoverage

description: At scale 1.0, the X and Y of the region affected by the height patch.

WeightPatches

type: TArray<TObject...

description: Weight patches.

ZeroHeightMeaning

description: How 0 height is interpreted.


description: UObject.

code: virtual void PostEditChangeProperty ( [FPropertyChangedEvent](API\Runtime\CoreUObject\UObject\FPropertyChangedEvent) & PropertyChangedEvent )


description: FObjectDuplicationParameters

code: virtual void PreDuplicate ( [FObjectDuplicationParameters](API\Runtime\CoreUObject\UObject\FObjectDuplicationParameters) & DupParams )


code: void SetSourceMode ( [ELandscapeTexturePatchSourceMode](API\Plugins\LandscapePatch\ELandscapeTexturePatchSourceMode) NewMode )


className: ULandscapeWeightPatchTextureInfo

description: Helper class forULandscapeTexturePatchthat stores information for a given weight layer. Should not be used outside this class, but does need to be aUObject(so can't be nested).

code: [UCLASS](Programming/UnrealArchitecture/Reference/Classes#classdeclaration)() class ULandscapeWeightPatchTextureInfo : public [UObject](API\Runtime\CoreUObject\UObject\UObject)

bEditVisibilityLayer

description: Specifies if this patch edits the visibility layer.

bOverrideBlendMode

description: Can't makeTOptionala UPROPERTY, hence these two.

bReinitializeOnNextRender

description: TODO: Like the similar flag for the height patch, this might not work once local merge works with landscape brushes...

EditCondition

description: Texture to use when source mode is set to texture asset.

OwningPatch

type: TWeakObjectPtr<...

description: Needed mainly so that we can get at the resolution...

WeightmapLayerName

type: FName


code: virtual void CopyToInternalTexture()


code: virtual void SetUseAlphaChannel ( bool bUseAlphaChannelIn )


description: Called before the module is unloaded, right before the module object is destroyed. During normal shutdown, this is called in reverse order that modules finishStartupModule(). This means that, as long as a module references dependent modules in it'sStartupModule(), it can safely reference those dependencies inShutdownModule()as well.

module: LandscapePatchEditorOnly

code: virtual void ShutdownModule()


description: IModuleInterfaceimplementation

code: virtual void StartupModule()


className: FLandscapePatchEditorOnlyModule

code: class FLandscapePatchEditorOnlyModule : public [IModuleInterface](API\Runtime\Core\Modules\IModuleInterface)


className: FLandscapeTexturePatchVisualizer

description: Adds a rectangle denoting the area covered by a landscape texture patch when it is selected in editor.

code: class FLandscapeTexturePatchVisualizer : public [FComponentVisualizer](API\Editor\UnrealEd\FComponentVisualizer)


className: FLauncherChunkInstaller

description: Launcher Implementation of the platform chunk install module

module: LauncherChunkInstaller

code: class FLauncherChunkInstaller : public [FGenericPlatformChunkInstall](API\Runtime\Core\GenericPlatform\FGenericPlatformChunkInstall)


description:
Get the current location of a chunk. Pakchunk index and platform chunk id are not always the same. Call GetPakchunkLocation instead of calling from outside.
Enum specifying whether the chunk is available to use, waiting to install, or does not exist.

code: virtual [EChunkLocation::Type](API\Runtime\Core\GenericPlatform\EChunkLocation__Type) GetChunkLocation ( uint32 ChunkID )


module: Learning

code: virtual void Encode ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: virtual void Decode ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: virtual bool IsDecodable() const


code: virtual bool IsEncodable() const


code: FAccelerationFeature ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InAccelerationNum, const float InScale )


className: FAccelerationFeature

description: Feature for an array of accelerations

code: struct FAccelerationFeature : public [UE::Learning::FFeatureObject](API\Plugins\Learning\FFeatureObject)

AccelerationHandle

type: TArrayMapHandle...


description: Reset the Optimizer

code: virtual void Reset ( [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 2, float > OutSamples, const [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 1, const float > InitialGuess )


description: Resize the Optimizer

code: virtual void Resize ( const int32 SampleNum, const int32 DimensionsNum )


description: Update the Optimizer

code: virtual void Update ( [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 2, float > InOutSamples, const [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 1, const float > Losses, const [ELogSetting](API\Plugins\Learning\UE__Learning__ELogSetting) LogSettings )


code: FAdamOptimizer ( const uint32 Seed, const [FAdamOptimizerSettings](API\Plugins\Learning\FAdamOptimizerSettings) & InSettings )


className: FAdamOptimizer

description: Estimates gradient via finite differencing and does gradient descent. Roughly based onhttps://arxiv.org/abs/1910.06513

code: struct FAdamOptimizer : public [UE::Learning::IOptimizer](API\Plugins\Learning\IOptimizer)


className: FAdamOptimizerSettings

code: struct FAdamOptimizerSettings

description: First moment momentum ratio. Reduce if seeing large swings in the loss.

description: Second moment momentum ratio. Reduce if seeing large swings in the loss.

FiniteDifferenceStd

description: The size of the std for finite differencing.

LearningRate

description: Update learning rate. Larger values may speed up convergence at the cost of instability.


code: FAngleFeature ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InAngleNum, const float InScale )


className: FAngleFeature

description: Feature for an array of angles

code: struct FAngleFeature : public [UE::Learning::FFeatureObject](API\Plugins\Learning\FFeatureObject)


code: FAngularAccelerationFeature ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InAngularAccelerationNum, const float InScale )


className: FAngularAccelerationFeature

description: Feature for an array of angular accelerations

code: struct FAngularAccelerationFeature : public [UE::Learning::FFeatureObject](API\Plugins\Learning\FFeatureObject)


className: FAngularVelocityFeature

description: Feature for an array of angular velocities

code: struct FAngularVelocityFeature : public [UE::Learning::FFeatureObject](API\Plugins\Learning\FFeatureObject)


code: virtual void Evaluate ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: FAnyCompletion ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 1, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FCompletionObject](API\Plugins\Learning\FCompletionObject) >> InCompletions, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum )


className: FAnyCompletion

description: Terminates if any of the provided completions terminate

code: struct FAnyCompletion : public [UE::Learning::FCompletionObject](API\Plugins\Learning\FCompletionObject)

Completions

type: TLearningArray<...


description:
Add a new array to the map
A handle to later retrieve a view of the array for reading or writing

code: template<uint8 DimNum, typename ElementType> [TArrayMapHandle](API\Plugins\Learning\TArrayMapHandle)< [DimNum](API\Plugins\Learning\FArrayMap\DimNum\1), ElementType > Add ( const [FArrayMapKey](API\Plugins\Learning\FArrayMapKey) Key, const [TLearningArrayShape](API\Plugins\Learning\TLearningArrayShape)< [DimNum](API\Plugins\Learning\FArrayMap\DimNum\1) > Shape, const ElementType Default )


description:
Add a view to an existing array to the map. Does not allocate any new storage.
A handle to later retrieve the value of the array for reading or writing

code: template<uint8 DimNum, typename ElementType> [TArrayMapHandle](API\Plugins\Learning\TArrayMapHandle)< [DimNum](API\Plugins\Learning\FArrayMap\DimNum\1), ElementType > AddView ( const [FArrayMapKey](API\Plugins\Learning\FArrayMapKey) Key, const [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< [DimNum](API\Plugins\Learning\FArrayMap\DimNum\1), ElementType > View )


description: Get a read-only view of an array.

code: template<uint8 DimNum, typename ElementType> [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< [DimNum](API\Plugins\Learning\FArrayMap\DimNum\1), const ElementType > ConstView ( const [FArrayMapKey](API\Plugins\Learning\FArrayMapKey) Key ) const


code: FAngularVelocityFeature ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InAngularAccelerationNum, const float InScale )


description: Get a read-only view of an array.

code: template<uint8 DimNum, typename ElementType> [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< [DimNum](API\Plugins\Learning\FArrayMap\DimNum\1), const ElementType > ConstView ( const [FArrayMapHandle](API\Plugins\Learning\FArrayMapHandle) Handle ) const


description: Get a read-only view of an array.

code: template<uint8 DimNum, typename ElementType> [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< [DimNum](API\Plugins\Learning\FArrayMap\DimNum\1), const ElementType > ConstView ( const [TArrayMapHandle](API\Plugins\Learning\TArrayMapHandle)< [DimNum](API\Plugins\Learning\FArrayMap\DimNum\1), ElementType > Handle ) const


description: Check if an array with the given name has already been added.

code: bool Contains ( const [FArrayMapKey](API\Plugins\Learning\FArrayMapKey) Key ) const


description: Get the number of dimensions of an array in the map.

code: uint8 DimNum ( const [FArrayMapKey](API\Plugins\Learning\FArrayMapKey) Key ) const


code: uint8 DimNum ( const [FArrayMapHandle](API\Plugins\Learning\FArrayMapHandle) Handle ) const


description: Clear all array data.

code: void Empty()


description: Find the array handle associated with a key. Returns `nullptr_ if Key is not in Map.

code: const [FArrayMapHandle](API\Plugins\Learning\FArrayMapHandle) * Find ( const [FArrayMapKey](API\Plugins\Learning\FArrayMapKey) Key ) const


description: Get the key associated with a particular handle

code: const [FArrayMapKey](API\Plugins\Learning\FArrayMapKey) * FindKey ( [FArrayMapHandle](API\Plugins\Learning\FArrayMapHandle) Handle ) const


className: FlagAllocated

description: Array is allocated by this map, so must be deallocated.

code: enum { FlagAllocated = 1 << 0 }


className: FlagConstructed

description: Array is constructed by this map, so must be destructed.

code: enum { FlagConstructed = 1 << 1 }


className: FlagLinked

description: Array is a link to another array.

code: enum { FlagLinked = 1 << 2 }


description: Get all keys in the map.

code: template<typename Allocator> void GetKeys ( [TArray](API\Runtime\Core\Containers\TArray)< [FArrayMapKey](API\Plugins\Learning\FArrayMapKey), Allocator > & OutKeys ) const


description: Check if the given array has a link.

code: bool HasLink ( const [FArrayMapKey](API\Plugins\Learning\FArrayMapKey) Dst ) const


description: Check if the given array has a link.

code: bool HasLink ( const [FArrayMapHandle](API\Plugins\Learning\FArrayMapHandle) Dst ) const


className: InlineArrayNum

code: static constexpr int32 InlineArrayNum = 128;


className: InlineScalarBytesNum

code: static constexpr int32 InlineScalarBytesNum = 2048;


description: Check if the given array is linked to.

code: bool IsLinkedTo ( const [FArrayMapKey](API\Plugins\Learning\FArrayMapKey) Src ) const


description: Check if the given array is linked to.

code: bool IsLinkedTo ( const [FArrayMapHandle](API\Plugins\Learning\FArrayMapHandle) Src ) const


description: Link one array to another such that they share the same data. Concretely, this function will make asking for a View of the Dst array return a view of the Src array instead. This version provides a type-safe interface for linking so should be used by default.

code: template<uint8 DimNum, typename ElementType> void Link ( const [TArrayMapHandle](API\Plugins\Learning\TArrayMapHandle)< [DimNum](API\Plugins\Learning\FArrayMap\DimNum\1), ElementType > Src, const [TArrayMapHandle](API\Plugins\Learning\TArrayMapHandle)< [DimNum](API\Plugins\Learning\FArrayMap\DimNum\1), ElementType > Dst )


description: Link one array to another as if they were flattened. This can be useful when the array dimensions don't exactly match such as with one dimension of a single element.

code: template<uint8 SrcDimNum, uint8 DstDimNum, typename ElementType> void LinkFlat ( const [TArrayMapHandle](API\Plugins\Learning\TArrayMapHandle)< SrcDimNum, ElementType > Src, const [TArrayMapHandle](API\Plugins\Learning\TArrayMapHandle)< DstDimNum, ElementType > Dst )


description: Link one array to another such that they share the same data. Concretely, this function will make asking for a View of the Dst array return a view of the Src array instead.

code: void LinkHandles ( const [FArrayMapHandle](API\Plugins\Learning\FArrayMapHandle) Src, const [FArrayMapHandle](API\Plugins\Learning\FArrayMapHandle) Dst )


code: void LinkKeys ( const [FArrayMapKey](API\Plugins\Learning\FArrayMapKey) Src, const [FArrayMapKey](API\Plugins\Learning\FArrayMapKey) Dst )


code: void LinkHandlesFlat ( const [FArrayMapHandle](API\Plugins\Learning\FArrayMapHandle) Src, const [FArrayMapHandle](API\Plugins\Learning\FArrayMapHandle) Dst )


description: Lookup the array handle associated with a key.

code: [FArrayMapHandle](API\Plugins\Learning\FArrayMapHandle) Lookup ( const [FArrayMapKey](API\Plugins\Learning\FArrayMapKey) Key ) const


className: MaxScalarAlignment

code: static constexpr int32 MaxScalarAlignment = 64;


className: MaxDimNum

code: static constexpr int32 MaxDimNum = 6;


description: Get the type id of an array in the map.

code: int16 TypeId ( const [FArrayMapKey](API\Plugins\Learning\FArrayMapKey) Key ) const


description: Get the type name of an array in the map.

code: const TCHAR * TypeName ( const [FArrayMapHandle](API\Plugins\Learning\FArrayMapHandle) Handle ) const


description: Get the type id of an array in the map.

code: int16 TypeId ( const [FArrayMapHandle](API\Plugins\Learning\FArrayMapHandle) Handle ) const


code: const TCHAR * TypeName ( const [FArrayMapKey](API\Plugins\Learning\FArrayMapKey) Key ) const


description: Get a view of an array.

code: template<uint8 DimNum, typename ElementType> [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< [DimNum](API\Plugins\Learning\FArrayMap\DimNum\1), ElementType > View ( const [FArrayMapKey](API\Plugins\Learning\FArrayMapKey) Key ) const


description: Get a view of an array.

code: template<uint8 DimNum, typename ElementType> [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< [DimNum](API\Plugins\Learning\FArrayMap\DimNum\1), ElementType > View ( const [FArrayMapHandle](API\Plugins\Learning\FArrayMapHandle) Handle ) const


description: Get a view of an array.

code: template<uint8 DimNum, typename ElementType> [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< [DimNum](API\Plugins\Learning\FArrayMap\DimNum\1), ElementType > View ( const [TArrayMapHandle](API\Plugins\Learning\TArrayMapHandle)< [DimNum](API\Plugins\Learning\FArrayMap\DimNum\1), ElementType > Handle ) const


className: FArrayMap

description: A map of differently sized and typed multi-dimensional arrays

code: struct FArrayMap


code: bool operator== ( const [FArrayMapHandle](API\Plugins\Learning\FArrayMapHandle) & Rhs ) const


className: FArrayMapHandle

description: Untyped handle to an array stored in anFArrayMap

code: struct FArrayMapHandle


code: bool operator== ( const [FArrayMapKey](API\Plugins\Learning\FArrayMapKey) & Other ) const


className: FArrayMapKey

description: Key type forFArrayMap. A pair of FNames - generally we can use one to identify the object itself, and one for the variable/member/field.

code: struct FArrayMapKey


description: Reset the Optimizer

code: virtual void Reset ( [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 2, float > OutSamples, const [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 1, const float > InitialGuess )


code: static int32 DefaultSampleNum ( const int32 DimensionNum )


description: Resize the Optimizer

code: virtual void Resize ( const int32 SampleNum, const int32 DimensionsNum )


description: Update the Optimizer

code: virtual void Update ( [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 2, float > InOutSamples, const [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 1, const float > Losses, const [ELogSetting](API\Plugins\Learning\UE__Learning__ELogSetting) LogSettings )


code: FCMAOptimizer ( const uint32 Seed, const [FCMAOptimizerSettings](API\Plugins\Learning\FCMAOptimizerSettings) & InSettings )


className: FCMAOptimizer

description: Black box optimizer based on Covariance Matrix Adaption

code: struct FCMAOptimizer : public [UE::Learning::IOptimizer](API\Plugins\Learning\IOptimizer)


className: FCMAOptimizerSettings

description: Settings for the CMA Optimizer

code: struct FCMAOptimizerSettings

InitialStepSize

description: The size of the initial exploration region for CMA.

SurvialRatio

description: What ratio of samples are used to update the covariance matrix and how many are discarded.


code: [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 1, [ECompletionMode](API\Plugins\Learning\UE__Learning__ECompletionMode) > CompletionBuffer()


code: void Evaluate ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: FCompletionObject ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const [ECompletionMode](API\Plugins\Learning\UE__Learning__ECompletionMode) InCompletionMode )


className: FCompletionObject

description: Base class for an object which computes if an instance should be completion from a set of other arrays. Here, all data is assumed to be stored in a `FArrayMap_ object to make the processing of multiple instances efficient.

code: struct FCompletionObject

CompletionMode

type: ECompletionMode

InstanceData

type: TSharedRef<FAr...


code: virtual void Decode ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: virtual void Encode ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: virtual bool IsDecodable() const


code: virtual bool IsEncodable() const


code: FConcatenateFeature ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 1, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FFeatureObject](API\Plugins\Learning\FFeatureObject) >> InFeatures, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const float InScale )


className: FConcatenateFeature

description: Feature that concatenates multiple other features

code: struct FConcatenateFeature : public [UE::Learning::FFeatureObject](API\Plugins\Learning\FFeatureObject)


code: virtual void Evaluate ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: FConditionalCompletion ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const [ECompletionMode](API\Plugins\Learning\UE__Learning__ECompletionMode) InCompletionMode )


className: FConditionalCompletion

description: Completion due to some condition being true

code: struct FConditionalCompletion : public [UE::Learning::FCompletionObject](API\Plugins\Learning\FCompletionObject)


className: FConditionalConstantReward

description: Conditional Constant Reward

code: struct FConditionalConstantReward : public [UE::Learning::FRewardObject](API\Plugins\Learning\FRewardObject)


code: FConditionalConstantReward ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const float InValue )


code: FConstantPenalty ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const float InValue )


className: FConstantPenalty

description: Constant Penalty

code: struct FConstantPenalty : public [UE::Learning::FRewardObject](API\Plugins\Learning\FRewardObject)


code: FConstantReward ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const float InValue )


className: FConstantReward

description: Constant Reward

code: struct FConstantReward : public [UE::Learning::FRewardObject](API\Plugins\Learning\FRewardObject)


code: FCopyVectorsFunction ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InDimensionsNum )


className: FCopyVectorsFunction

description: Copies vector data from one array to another

code: struct FCopyVectorsFunction : public [UE::Learning::FFunctionObject](API\Plugins\Learning\FFunctionObject)


code: virtual void Decode ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: virtual void Encode ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: virtual bool IsDecodable() const


code: virtual bool IsEncodable() const


code: FDirectionFeature ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InDirectionNum, const float InScale )


className: FDirectionFeature

description: Feature for an array of directions

code: struct FDirectionFeature : public [UE::Learning::FFeatureObject](API\Plugins\Learning\FFeatureObject)


code: virtual void Evaluate ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: FExtractPositionsAndRotationsFromTransformsFunction ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum )


description: Computes positions and rotations given transforms

code: struct FExtractPositionsAndRotationsFromTransformsFunction : public [UE::Learning::FFunctionObject](API\Plugins\Learning\FFunctionObject)


code: FExtractRotationsFromTransformsFunction ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum )


className: FExtractRotationsFromTransformsFunction

description: Computes rotations given transforms

code: struct FExtractRotationsFromTransformsFunction : public [UE::Learning::FFunctionObject](API\Plugins\Learning\FFunctionObject)


description: Penalty based on the difference between two rotations facing directions

code: struct FFacingDirectionAngularDifferencePenalty : public [UE::Learning::FRewardObject](API\Plugins\Learning\FRewardObject)


code: FFacingDirectionAngularDifferencePenalty ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const FVector InFacingDirection0, const FVector InFacingDirection1, const float InWeight, const float InScale, const float InThreshold )


code: FFacingTowardsTargetAngularDifferencePenalty ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const FVector InFacingDirection, const float InMinRadius, const float InWeight, const float InScale, const float InThreshold )


code: void Decode ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


description: Penalty based on the difference between a rotation facing direction and a position

code: struct FFacingTowardsTargetAngularDifferencePenalty : public [UE::Learning::FRewardObject](API\Plugins\Learning\FRewardObject)


code: void Encode ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 2, float > FeatureBuffer()


code: FFeatureObject ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InFeatureDimNum, const float InScale )


className: FFeatureObject

description: Base class for an object which can do the encoding or decoding of features from a set of other arrays. Here, all data is assumed to be stored in a `FArrayMap_ object to make the processing of multiple instances efficient.

code: struct FFeatureObject


code: virtual void Decode ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: virtual void Encode ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: virtual bool IsDecodable() const


code: virtual bool IsEncodable() const


code: FFloatFeature ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InFloatNum, const float InScale )


className: FFloatFeature

description: Feature for an array of floats

code: struct FFloatFeature : public [UE::Learning::FFeatureObject](API\Plugins\Learning\FFeatureObject)


code: virtual void Evaluate ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: FFloatReward ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const float InWeight )


className: FFloatReward

description: Basic Float Reward

code: struct FFloatReward : public [UE::Learning::FRewardObject](API\Plugins\Learning\FRewardObject)


code: FFunctionObject ( const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData )


code: void Evaluate ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


className: FFunctionObject

description: Base class for an object which outputs to some arrays stored in a[FArrayMap](API\Plugins\Learning\FArrayMap)_, using other arrays in theFArrayMapas input. Here, all data is assumed to be stored in a `FArrayMapobject to make the processing of multiple instances efficient.

code: struct FFunctionObject


code: bool Contains ( const int32 Index ) const


code: [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 1, const int32 > GetIndices() const


code: [FIndexSet](API\Plugins\Learning\FIndexSet) & operator= ( const int32 InSingleIndex )


code: [FIndexSet](API\Plugins\Learning\FIndexSet) & operator= ( const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const int32 > InIndices )


code: [FIndexSet](API\Plugins\Learning\FIndexSet) & operator= ( [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 1, const int32 > InIndices )


code: template<typename InAllocatorType> [FIndexSet](API\Plugins\Learning\FIndexSet) & operator= ( const [TArray](API\Runtime\Core\Containers\TArray)< int32, InAllocatorType > & InIndices )


code: template<typename InAllocatorType> [FIndexSet](API\Plugins\Learning\FIndexSet) & operator= ( const [TLearningArray](API\Plugins\Learning\TLearningArray)< 1, int32, InAllocatorType > & InIndices )


code: int32 operator[] ( const int32 Index ) const


code: [FIndexSet](API\Plugins\Learning\FIndexSet) Slice ( const int32 InStart, const int32 InNum ) const


code: [TArray](API\Runtime\Core\Containers\TArray)< int32 > ToArray() const


description:
Warning: this algorithm works on the assumption that there are no duplicate indices in the view. If there are duplicate indices in your set this will not give the correct result.
true if conversion to a slice is successful

code: bool TryMakeSlice()


code: FIndexSet ( const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const int32 > InIndices )


code: FIndexSet ( const [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 1, const int32 > InIndices )


code: FIndexSet ( std::initializer_list< int32 > InIndices )


code: FIndexSet ( const int32 InSingleIndex )


code: template<typename InAllocatorType> FIndexSet ( const [TArray](API\Runtime\Core\Containers\TArray)< int32, InAllocatorType > & InIndices )


code: template<typename InAllocatorType> FIndexSet ( const [TLearningArray](API\Plugins\Learning\TLearningArray)< 1, int32, InAllocatorType > & InIndices )


code: FIndexSet ( const int32 InSliceStart, const int32 InSliceNum )


className: FIndexSet

description: We can also attempt to automatically convert index sets which contain consecutive indices from arrays of int32 to slices using the `TryMakeSlice_ function for more efficient processing.

code: struct FIndexSet


code: bool operator!= ( const [FIndexSetIterator](API\Plugins\Learning\FIndexSetIterator) & Rhs ) const


code: FIndexSetIterator ( const int32 * InPtr )


code: FIndexSetIterator ( int32 InIndex )


className: FIndexSetIterator

description: Iterator forFIndexSet(see below)

code: struct FIndexSetIterator


description: Called before the module is unloaded, right before the module object is destroyed. During normal shutdown, this is called in reverse order that modules finishStartupModule(). This means that, as long as a module references dependent modules in it'sStartupModule(), it can safely reference those dependencies inShutdownModule()as well.

code: virtual void ShutdownModule()


description: IModuleInterfaceimplementation

code: virtual void StartupModule()


className: FLearningModule

code: class FLearningModule : public [IModuleInterface](API\Runtime\Core\Modules\IModuleInterface)


code: virtual void Evaluate ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: FLocalDirectionalVelocityReward ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const float InWeight, const float InScale, const FVector InAxis )


className: FLocalDirectionalVelocityReward

description: Reward based on how large a velocity is in a particular local direction

code: struct FLocalDirectionalVelocityReward : public [UE::Learning::FRewardObject](API\Plugins\Learning\FRewardObject)

Axis

type: FVector


code: void DeserializeFromBytes ( int32 & InOutOffset, const [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 1, const uint8 > RawBytes )


code: static int32 GetSerializationByteNum ( const int32 InputNum, const int32 OutputNum, const int32 HiddenNum, const int32 LayerNum )


code: void Resize ( const int32 InputNum, const int32 OutputNum, const int32 HiddenNum, const int32 LayerNum )


code: void SerializeToBytes ( int32 & InOutOffset, [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 1, uint8 > OutRawBytes ) const


className: FNeuralNetwork

description: Simple feed-forward network data.

code: struct FNeuralNetwork

ActivationFunction

type: EActivationFunc...

Biases

type: TArray<TLearni...


code: FNeuralNetworkCriticFunction ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FNeuralNetwork](API\Plugins\Learning\FNeuralNetwork) > & InNeuralNetwork, const [FNeuralNetworkCriticFunctionSettings](API\Plugins\Learning\FNeuralNetworkCriticFunctionSett-) & InSettings )


className: FNeuralNetworkCriticFunction

description: Neural-network based critic object. Stores various settings and intermediate storage required to evaluate the given network for the provided number of instances.

code: struct FNeuralNetworkCriticFunction : public [UE::Learning::FFunctionObject](API\Plugins\Learning\FFunctionObject)

NeuralNetwork

type: TSharedRef<FNe...

Settings

type: FNeuralNetworkC...


className: FNeuralNetworkCriticFunctionSettings

description: Settings object for a neural network based critic

bParallelEvaluation

type: bool

description: If to allow for multi-threaded evaluation.

MinParallelBatchSize

description: Minimum batch size to use for multi-threaded evaluation.


code: FNeuralNetworkPolicyFunction ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FNeuralNetwork](API\Plugins\Learning\FNeuralNetwork) > & InNeuralNetwork, const uint32 InSeed, const [FNeuralNetworkPolicyFunctionSettings](API\Plugins\Learning\FNeuralNetworkPolicyFunctionSett-) & InSettings )


className: FNeuralNetworkPolicyFunction

description: Neural-network based policy object. Stores various settings and intermediate storage required to evaluate the given network for the provided number of instances.

code: struct FNeuralNetworkPolicyFunction : public [UE::Learning::FFunctionObject](API\Plugins\Learning\FFunctionObject)

Settings

type: FNeuralNetworkP...


className: FNeuralNetworkPolicyFunctionSettings

description: Settings object for a neural network based policy

ActionNoiseMax

type: float

description: Maximum amount of action noise to allow.

ActionNoiseMin

description: Minimum amount of action noise to allow.

ActionNoiseScale

description: Overall scale of the action noise.


className: FOptimizationPlannerBuffer

description: Basic buffer containing some additional data used during optimization planning

code: struct FOptimizationPlannerBuffer


code: void Resize ( const int32 SampleNum, const int32 StepNum, const int32 ActionVectorDimensionNum )


description:
Fits a PCA transform to some data
Result of PCA fitting process. Used to check for success.

code: [FPCAResult](API\Plugins\Learning\FPCAResult) Fit ( const [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 2, const float > Data, const [FPCASettings](API\Plugins\Learning\FPCASettings) & Settings, const [ELogSetting](API\Plugins\Learning\UE__Learning__ELogSetting) LogSettings, [FProgress](API\Plugins\Learning\FProgress) * Progress )


description: Inverse Transform a single vector using the PCA transformation

code: void InverseTransform ( [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 1, float > OutData, const [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 1, const float > Data ) const


code: bool Serialize ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar )


description: Transform multiple vectors using the PCA transformation

code: void Transform ( [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 2, float > OutData, const [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 2, const float > Data, [FProgress](API\Plugins\Learning\FProgress) * Progress ) const


description: Transform a single vector using the PCA transformation

code: void Transform ( [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 1, float > OutData, const [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 1, const float > Data ) const


className: FPCAEncoder

description: Represents a PCA transformation which can be used to encode data

code: struct FPCAEncoder


className: FPCAResult

description: Details of the result of the PCA fitting.

code: struct FPCAResult

bSuccess

description: Was the PCA transform fit successfully.

DimensionNum

description: How many dimensions were kept by the PCA transform.

VarianceRatioPreserved

description: Number between 0 and 1 saying how much of the variance is preserved.


className: FPCASettings

description: PCA settings. The resulting number of dimensions will be based on whatever is lower betweenMaximumDimensions_, and however many dimensions preserve the givenMaximumVarianceRatio_. If the PCA computation is failing ensure `bStableComputation_ is set to true as the non-stable version fails more often than I would expect.

code: struct FPCASettings

bStableComputation

description: Use a slower but stable version of the computation.

MaximumDimensions

description: Maximum number of dimensions to keep.

MaximumVarianceRatio

description: Maximum variance ratio to preserve.

Subsample

description: Rate at which to subsample the data when computing the PCA encoding.


code: virtual void Decode ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: virtual void Encode ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: virtual bool IsEncodable() const


code: virtual bool IsDecodable() const


code: FPlanarAccelerationFeature ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InAccelerationNum, const float InScale, const FVector InAxis0, const FVector InAxis1 )


className: FPlanarAccelerationFeature

description: Feature for an array of planar accelerations

code: struct FPlanarAccelerationFeature : public [UE::Learning::FFeatureObject](API\Plugins\Learning\FFeatureObject)


code: FPlanarAngularAccelerationFeature ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InAngularAccelerationNum, const float InScale, const FVector InAxis )


className: FPlanarAngularAccelerationFeature

description: Feature for an array of planar angular accelerations

code: struct FPlanarAngularAccelerationFeature : public [UE::Learning::FFeatureObject](API\Plugins\Learning\FFeatureObject)


code: FPlanarDirectionFeature ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InDirectionNum, const float InScale, const FVector InAxis0, const FVector InAxis1 )


className: FPlanarDirectionFeature

description: Feature for an array of planar directions

code: struct FPlanarDirectionFeature : public [UE::Learning::FFeatureObject](API\Plugins\Learning\FFeatureObject)


code: virtual void Evaluate ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: FPlanarPositionDifferenceCompletion ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InPositionNum, const float InThreshold, const [ECompletionMode](API\Plugins\Learning\UE__Learning__ECompletionMode) InCompletionMode, const FVector InAxis0, const FVector InAxis1 )


className: FPlanarPositionDifferenceCompletion

description: Completion due to the difference between any two planar positions exceeding a given threshold

code: struct FPlanarPositionDifferenceCompletion : public [UE::Learning::FCompletionObject](API\Plugins\Learning\FCompletionObject)


code: FPlanarPositionDifferencePenalty ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const float InWeight, const float InScale, const float InThreshold, const FVector InAxis0, const FVector InAxis1 )


className: FPlanarPositionDifferencePenalty

description: Penalty based on the difference between two planar positions

code: struct FPlanarPositionDifferencePenalty : public [UE::Learning::FRewardObject](API\Plugins\Learning\FRewardObject)


code: FPlanarPositionFeature ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InPositionNum, const float InScale, const FVector InAxis0, const FVector InAxis1 )


className: FPlanarPositionFeature

description: Feature for an array of planar positions

code: struct FPlanarPositionFeature : public [UE::Learning::FFeatureObject](API\Plugins\Learning\FFeatureObject)


code: FPlanarPositionSimilarityCompletion ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InPositionNum, const float InThreshold, const [ECompletionMode](API\Plugins\Learning\UE__Learning__ECompletionMode) InCompletionMode, const FVector InAxis0, const FVector InAxis1 )


className: FPlanarPositionSimilarityCompletion

description: Completion due to the similarity between any two planar positions being below a given threshold

code: struct FPlanarPositionSimilarityCompletion : public [UE::Learning::FCompletionObject](API\Plugins\Learning\FCompletionObject)


code: virtual void Decode ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: virtual void Encode ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: virtual bool IsDecodable() const


code: virtual bool IsEncodable() const


className: FPlanarVelocityFeature

description: Feature for an array of planar velocities

code: struct FPlanarVelocityFeature : public [UE::Learning::FFeatureObject](API\Plugins\Learning\FFeatureObject)


code: FPlanarVelocityFeature ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InVelocityNum, const float InScale, const FVector InAxis0, const FVector InAxis1 )


code: FPositionArraySimilarityReward ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InPositionNum, const float InWeight, const float InScale, const float InThreshold )


className: FPositionArraySimilarityReward

description: Reward based on the similarity between two arrays of position

code: struct FPositionArraySimilarityReward : public [UE::Learning::FRewardObject](API\Plugins\Learning\FRewardObject)


code: FPositionDifferencePenalty ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const float InWeight, const float InScale, const float InThreshold )


code: virtual void Evaluate ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


className: FPositionDifferencePenalty

description: Penalty based on the difference between two positions

code: struct FPositionDifferencePenalty : public [UE::Learning::FRewardObject](API\Plugins\Learning\FRewardObject)


code: FPositionFeature ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InPositionNum, const float InScale )


className: FPositionFeature

description: Feature for an array of positions

code: struct FPositionFeature : public [UE::Learning::FFeatureObject](API\Plugins\Learning\FFeatureObject)


code: void Decrement ( const int32 Num )


code: void GetMessage ( [FText](API\Runtime\Core\Internationalization\FText) & OutMessage )


code: void SetMessage ( const [FText](API\Runtime\Core\Internationalization\FText) & InMessage )


code: void SetProgress ( const int32 InProgress )


className: FProgress

description: Simple thread-safe structure to record progress of some long-running computation.

code: struct FProgress


description: Resize the Optimizer

code: virtual void Resize ( const int32 SampleNum, const int32 DimensionsNum )


description: Reset the Optimizer

code: virtual void Reset ( [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 2, float > OutSamples, const [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 1, const float > InitialGuess )


description: Update the Optimizer

code: virtual void Update ( [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 2, float > InOutSamples, const [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 1, const float > Losses, const [ELogSetting](API\Plugins\Learning\UE__Learning__ELogSetting) LogSettings )


code: FPSOOptimizer ( const uint32 Seed, const [FPSOOptimizerSettings](API\Plugins\Learning\FPSOOptimizerSettings) & InSettings )


className: FPSOOptimizerSettings

description: Settings for the PSO Optimizer. Defaults fromhttps://www.jstage.jst.go.jp/article/imt/3/1/3_1_103/_pdf/-char/ja

code: struct FPSOOptimizerSettings

GlobalGain

description: Amount to pull particles toward the global best.

LocalGain

description: Amount to pull particles toward their local best.

Momentum

description: How much of the particle velocity to preserve between steps.


className: FPSOOptimizer

description: Gradient free optimizer based on Particle Swarm Optimization

code: struct FPSOOptimizer : public [UE::Learning::IOptimizer](API\Plugins\Learning\IOptimizer)


code: FRandomPlanarClippedGaussianFunction ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InValueNum, const uint32 InSeed, const float InMean, const float InStd, const float InClip, const FVector InAxis0, const FVector InAxis1 )


className: FRandomPlanarClippedGaussianFunction

description: Samples values from a planar clipped Gaussian distribution.

code: struct FRandomPlanarClippedGaussianFunction : public [UE::Learning::FFunctionObject](API\Plugins\Learning\FFunctionObject)


code: virtual void Evaluate ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: FRandomPlanarDirectionFunction ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InDirectionNum, const uint32 InSeed, const FVector InAxis0, const FVector InAxis1 )


className: FRandomPlanarDirectionFunction

description: Samples planar directions.

code: struct FRandomPlanarDirectionFunction : public [UE::Learning::FFunctionObject](API\Plugins\Learning\FFunctionObject)


code: FRandomPlanarDirectionVelocityFunction ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InDirectionVelocityNum, const uint32 InSeed, const float InVelocityScale, const FVector InAxis0, const FVector InAxis1 )


className: FRandomPlanarDirectionVelocityFunction

description: Samples planar directions with corresponding velocities.

code: struct FRandomPlanarDirectionVelocityFunction : public [UE::Learning::FFunctionObject](API\Plugins\Learning\FFunctionObject)


code: FRandomUniformFunction ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InValueNum, const uint32 InSeed, const float InMin, const float InMax )


className: FRandomUniformFunction

description: Samples scalar values from a uniform distribution

code: struct FRandomUniformFunction : public [UE::Learning::FFunctionObject](API\Plugins\Learning\FFunctionObject)


description: Record an array from the providedSrcArrayMap_ in theLogArrayMap_

code: template<uint8 DimNum, typename ElementType> void Add ( const [FArrayMapKey](API\Plugins\Learning\FArrayMapKey) Key )


code: [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 1, const int32 > GetStepNums() const


description: Reset all recorded arrays

code: void Reset ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: FRecorderObject ( const int32 InMaxInstanceNum, const int32 InMaxStepNum, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InSrcArrayMap, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InLogArrayMap )


description: Update all recorded arrays (record their current value)

code: void Update ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


className: FRecorderObject

description: This object assumes the first dimension on all arrays corresponds toInstances_, as it works by only record updates and resets for certainInstances_ given by an[FIndexSet](API\Plugins\Learning\FIndexSet)_. This makes it easier to use in conjunction with the other objects that useFArrayMapsuch as `FRewardObject.

code: struct FRecorderObject


code: const int32 GetResetInstanceNum() const


code: const [FIndexSet](API\Plugins\Learning\FIndexSet) GetResetInstances() const


code: void Resize ( const int32 InMaxInstanceNum )


code: void SetResetInstances ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: void SetResetInstancesFromCompletions ( const [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 1, const [ECompletionMode](API\Plugins\Learning\UE__Learning__ECompletionMode) > Completions, const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


className: FResetInstanceBuffer

description: This object stores essentially a list of instances that need to be reset. It can be filled based on the completion status or manually.

code: struct FResetInstanceBuffer


code: void Evaluate ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 1, float > RewardBuffer()


code: FRewardObject ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum )


code: virtual void Decode ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: virtual void Encode ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: virtual bool IsDecodable() const


code: virtual bool IsEncodable() const


className: FRotationFeature

description: Feature for an array of rotations

code: struct FRotationFeature : public [UE::Learning::FFeatureObject](API\Plugins\Learning\FFeatureObject)


code: FRotationFeature ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InRotationNum, const float InScale )


className: FRewardObject

description: Base class for an object which computes a reward or penalty value from a set of other arrays. Here, all data is assumed to be stored in a `FArrayMap_ object to make the processing of multiple instances efficient.

code: struct FRewardObject


code: FRotationVectorFeature ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InRotationVectorNum, const float InScale )


className: FRotationVectorFeature

description: Feature for an array of rotation vectors

code: struct FRotationVectorFeature : public [UE::Learning::FFeatureObject](API\Plugins\Learning\FFeatureObject)


code: FScalarAccelerationFeature ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InAccelerationNum, const float InScale )


className: FScalarAccelerationFeature

description: Feature for an array of scalar accelerations

code: struct FScalarAccelerationFeature : public [UE::Learning::FFeatureObject](API\Plugins\Learning\FFeatureObject)


className: FScalarAngularAccelerationFeature

description: Feature for an array of scalar angular accelerations

code: struct FScalarAngularAccelerationFeature : public [UE::Learning::FFeatureObject](API\Plugins\Learning\FFeatureObject)


code: FScalarAngularAccelerationFeature ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InAngularAccelerationNum, const float InScale )


code: virtual void Evaluate ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


description: Completion due to the difference between two scalar angular velocities exceeding a given threshold

code: struct FScalarAngularVelocityDifferenceCompletion : public [UE::Learning::FCompletionObject](API\Plugins\Learning\FCompletionObject)


code: FScalarAngularVelocityDifferenceCompletion ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InAngularVelocityNum, const float InThreshold, const [ECompletionMode](API\Plugins\Learning\UE__Learning__ECompletionMode) InCompletionMode )


code: FScalarAngularVelocityFeature ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InAngularAccelerationNum, const float InScale )


className: FScalarAngularVelocityFeature

description: Feature for an array of scalar angular velocities

code: struct FScalarAngularVelocityFeature : public [UE::Learning::FFeatureObject](API\Plugins\Learning\FFeatureObject)


code: FScalarAngularVelocitySimilarityReward ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const float InWeight, const float InScale, const float InThreshold )


className: FScalarAngularVelocitySimilarityReward

description: Reward based on the similarity between two scalar angular velocities

code: struct FScalarAngularVelocitySimilarityReward : public [UE::Learning::FRewardObject](API\Plugins\Learning\FRewardObject)


code: FScalarPositionDifferenceCompletion ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InPositionNum, const float InThreshold, const [ECompletionMode](API\Plugins\Learning\UE__Learning__ECompletionMode) InCompletionMode )


className: FScalarPositionDifferenceCompletion

description: Completion due to the difference between any two scalar positions exceeding a given threshold

code: struct FScalarPositionDifferenceCompletion : public [UE::Learning::FCompletionObject](API\Plugins\Learning\FCompletionObject)


code: virtual void Decode ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: virtual void Encode ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: virtual bool IsEncodable() const


code: FScalarPositionFeature ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InPositionNum, const float InScale )


code: virtual bool IsDecodable() const


className: FScalarPositionFeature

description: Feature for an array of scalar positions

code: struct FScalarPositionFeature : public [UE::Learning::FFeatureObject](API\Plugins\Learning\FFeatureObject)


code: FScalarPositionSimilarityReward ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const float InWeight, const float InScale, const float InThreshold )


className: FScalarPositionSimilarityReward

description: Reward based on the similarity between two scalar position

code: struct FScalarPositionSimilarityReward : public [UE::Learning::FRewardObject](API\Plugins\Learning\FRewardObject)


code: virtual void Evaluate ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: FScalarRotationDifferenceCompletion ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InRotationNum, const float InThreshold, const [ECompletionMode](API\Plugins\Learning\UE__Learning__ECompletionMode) InCompletionMode )


className: FScalarRotationDifferenceCompletion

description: Completion due to the difference between any two scalar rotations exceeding a given threshold

code: struct FScalarRotationDifferenceCompletion : public [UE::Learning::FCompletionObject](API\Plugins\Learning\FCompletionObject)


code: FScalarRotationSimilarityReward ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const float InWeight, const float InScale, const float InThreshold )


code: FScalarVelocityDifferenceCompletion ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InVelocityNum, const float InThreshold, const [ECompletionMode](API\Plugins\Learning\UE__Learning__ECompletionMode) InCompletionMode )


className: FScalarVelocityDifferenceCompletion

description: Completion due to the difference between any two scalar velocities exceeding a given threshold

code: struct FScalarVelocityDifferenceCompletion : public [UE::Learning::FCompletionObject](API\Plugins\Learning\FCompletionObject)


className: FScalarRotationSimilarityReward

description: Reward based on the similarity between two rotations

code: struct FScalarRotationSimilarityReward : public [UE::Learning::FRewardObject](API\Plugins\Learning\FRewardObject)


code: FScalarVelocityFeature ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InVelocityNum, const float InScale )


className: FScalarVelocityFeature

description: Feature for an array of scalar velocities

code: struct FScalarVelocityFeature : public [UE::Learning::FFeatureObject](API\Plugins\Learning\FFeatureObject)


className: FScalarVelocityReward

description: Reward based on how large (and positive) a scalar velocity is

code: struct FScalarVelocityReward : public [UE::Learning::FRewardObject](API\Plugins\Learning\FRewardObject)


code: FScalarVelocityReward ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const float InWeight, const float InScale )


code: virtual void Decode ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: virtual void Encode ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: virtual bool IsDecodable() const


code: FScaleFeature ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const int32 InScaleNum, const float InScale )


code: virtual bool IsEncodable() const


className: FScaleFeature

description: Feature for an array of scales

code: struct FScaleFeature : public [UE::Learning::FFeatureObject](API\Plugins\Learning\FFeatureObject)


code: FScopeNullableReadLock ( FRWLock * InLock )


code: FScopeNullableReadLock ( const [FScopeNullableReadLock](API\Plugins\Learning\FScopeNullableReadLock) & InScopeLock )


code: [FScopeNullableReadLock](API\Plugins\Learning\FScopeNullableReadLock) & operator= ( [FScopeNullableReadLock](API\Plugins\Learning\FScopeNullableReadLock) & InScopeLock )


className: FScopeNullableReadLock

description: Scoped read lock, which can optionally be null

code: struct FScopeNullableReadLock


code: [FScopeNullableWriteLock](API\Plugins\Learning\FScopeNullableWriteLock) & operator= ( [FScopeNullableWriteLock](API\Plugins\Learning\FScopeNullableWriteLock) & InScopeLock )


code: FScopeNullableWriteLock ( FRWLock * InLock )


code: FScopeNullableWriteLock ( const [FScopeNullableWriteLock](API\Plugins\Learning\FScopeNullableWriteLock) & InScopeLock )


className: FScopeNullableWriteLock

description: Scoped write lock, which can optionally be null

code: struct FScopeNullableWriteLock


code: virtual void Evaluate ( const [FIndexSet](API\Plugins\Learning\FIndexSet) Instances )


code: FSequentialFunction ( const [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 1, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FFunctionObject](API\Plugins\Learning\FFunctionObject) >> InFunctions, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData )


className: FSequentialFunction

description: Executes another set of function objects in sequence

code: struct FSequentialFunction : public [UE::Learning::FFunctionObject](API\Plugins\Learning\FFunctionObject)


code: FSpringInertializationPenalty ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum, const float InWeight, const float InScale, const float InThreshold )


className: FSpringInertializationPenalty

code: struct FSpringInertializationPenalty : public [UE::Learning::FRewardObject](API\Plugins\Learning\FRewardObject)


code: FSumReward ( const [FName](API\Runtime\Core\UObject\FName) & InIdentifier, const [TLearningArrayView](API\Plugins\Learning\TLearningArrayView)< 1, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FRewardObject](API\Plugins\Learning\FRewardObject) >> InRewards, const [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< [FArrayMap](API\Plugins\Learning\FArrayMap) > & InInstanceData, const int32 InMaxInstanceNum )