#include "Misc/EnumClassFlags.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "UObject/Class.h"
#include "Templates/SubclassOf.h"
#include "Engine/TimerHandle.h"
#include "Engine/NaniteAssemblyData.h"
#include "UObject/StrProperty.h"
#include "EngineTypes.generated.h"

Classes
struct	FAttachmentTransformRules

struct	FDetachmentTransformRules

struct	FLightingChannels

struct	FViewLightingChannels

struct	FMaterialShadingModelField

struct	FSubstrateMaterialInfo

struct	TStructOpsTypeTraits< FSubstrateMaterialInfo >

struct	FResponseChannel

struct	FCollisionResponseContainer

struct	FCollisionEnabledMask

struct	FRigidBodyErrorCorrection

struct	FRigidBodyContactInfo

struct	FCollisionImpactData

struct	FFractureEffect

struct	FBasedPosition

struct	FRotationConversionCache

struct	FSubtitleCue

struct	FLightmassLightSettings

struct	FLightmassPointLightSettings

struct	FLightmassDirectionalLightSettings

struct	FLightmassPrimitiveSettings

struct	FLightmassDebugOptions

struct	FSwarmDebugOptions

struct	FMTDResult

struct	FAnimSlotDesc

struct	FAnimUpdateRateParameters

struct	FPOV

struct	FMeshBuildSettings

struct	FSkeletalMeshBuildSettings

struct	FMeshDisplacementMap

struct	FMeshNaniteSettings

struct	FDisplacementScaling

struct	FDisplacementFadeRange

struct	FMeshRayTracingProxySettings

struct	FWalkableSlopeOverride

struct	TIsPODType< FWalkableSlopeOverride >

struct	FReplicationFlags

struct	FConstrainComponentPropName

struct	FBaseComponentReference

struct	FComponentReference

struct	FSoftComponentReference

struct	TStructOpsTypeTraits< FSoftComponentReference >

class	UEngineTypes

struct	FComponentSocketDescription

struct	FCollectionReference

struct	FRedirector

struct	FDebugFloatHistory

struct	FDepthFieldGlowInfo

struct	FFontRenderInfo

struct	FCanvasUVTri

struct	TIsZeroConstructType< FCanvasUVTri >

struct	FUserActivity

Namespaces
namespace	EBrowseReturnVal

namespace	EAttachLocation

namespace	ETranslucentSortPolicy

namespace	EDynamicGlobalIlluminationMethod

namespace	EReflectionMethod

namespace	EShadowMapMethod

namespace	ECastRayTracedShadow

namespace	EMegaLightsShadowMethod

namespace	EGBufferFormat

namespace	EParticleCollisionMode

namespace	ESubstrateStorageFormat

namespace	ESubstrateClosureConfig

namespace	EWorldType

namespace	ECollisionEnabled

namespace	EAutoReceiveInput

namespace	EEndPlayReason

namespace	EPhysicalMaterialMaskColor

namespace	EComponentMobility

namespace	EComponentSocketType

Macros
#define	NUM_LIGHTING_CHANNELS 3

#define	SUBSTRATE_TREE_MAX_DEPTH 48

#define	COLLISION_GIZMO ECC_EngineTraceChannel1

Enumerations
enum	{ NumInlinedActorComponents = 24 }

enum	EAspectRatioAxisConstraint : int { UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , AspectRatio_MAX }

enum	EBrowseReturnVal::Type { EBrowseReturnVal::Success , EBrowseReturnVal::Failure , EBrowseReturnVal::Pending }

enum class	EAttachmentRule : uint8 { KeepRelative , KeepWorld , SnapToTarget }

enum class	EDetachmentRule : uint8 { KeepRelative , KeepWorld }

enum	EAttachLocation::Type : int { EAttachLocation::KeepRelativeOffset , EAttachLocation::KeepWorldPosition , EAttachLocation::UMETA =(DisplayName = "Snap to Target, Keep World Scale") , EAttachLocation::UMETA =(DisplayName = "Snap to Target, Keep World Scale") }

enum	ESceneDepthPriorityGroup : int { SDPG_World , SDPG_Foreground , SDPG_MAX }

enum	EIndirectLightingCacheQuality : int { ILCQ_Off , ILCQ_Point , ILCQ_Volume }

enum class	ELightmapType : uint8 { Default , ForceSurface , ForceVolumetric }

enum	EOcclusionCombineMode : int { OCM_Minimum , OCM_Multiply , OCM_MAX }

enum	EBlendMode : int { UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , BLEND_TranslucentGreyTransmittance = BLEND_Translucent UMETA(Hidden, DisplayName = "Translucent - Grey Transmittance") , BLEND_ColoredTransmittanceOnly = BLEND_Modulate UMETA(Hidden, DisplayName = "Colored Transmittance Only") }

enum	EMaterialFloatPrecisionMode : int { UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , MFPM_MAX }

enum	ESamplerSourceMode : int { UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") }

enum	ETextureMipValueMode : int { UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , TMVM_MAX }

enum	ETranslucencyLightingMode : int { UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , TLM_MAX }

enum	ERefractionMode : int { UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") }

enum	ERefractionCoverageMode : int { UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") }

enum	EPixelDepthOffsetMode : int { UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") }

enum	ETranslucentSortPolicy::Type : int { ETranslucentSortPolicy::SortByDistance = 0 , ETranslucentSortPolicy::SortByProjectedZ = 1 , ETranslucentSortPolicy::SortAlongAxis = 2 }

enum	EDynamicGlobalIlluminationMethod::Type : int { EDynamicGlobalIlluminationMethod::None , EDynamicGlobalIlluminationMethod::Lumen , EDynamicGlobalIlluminationMethod::UMETA =(DisplayName="Screen Space (Beta)") , EDynamicGlobalIlluminationMethod::UMETA =(DisplayName="Screen Space (Beta)") }

enum	EReflectionMethod::Type : int { EReflectionMethod::None , EReflectionMethod::Lumen , EReflectionMethod::UMETA =(DisplayName="Screen Space") }

enum	EShadowMapMethod::Type : int { EShadowMapMethod::UMETA =(DisplayName = "Shadow Maps") , EShadowMapMethod::UMETA =(DisplayName = "Shadow Maps") }

enum	ECastRayTracedShadow::Type : int { ECastRayTracedShadow::Disabled , ECastRayTracedShadow::UseProjectSetting , ECastRayTracedShadow::Enabled }

enum	EMegaLightsShadowMethod::Type : int { EMegaLightsShadowMethod::Default , EMegaLightsShadowMethod::RayTracing , EMegaLightsShadowMethod::VirtualShadowMap }

enum	ESceneCaptureSource : int { UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , SCS_MAX }

enum	ESceneCaptureCompositeMode : int { UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") }

enum	EGBufferFormat::Type : int { EGBufferFormat::Force8BitsPerChannel = 0 UMETA(DisplayName = "Force 8 Bits Per Channel") , EGBufferFormat::Default = 1 , EGBufferFormat::HighPrecisionNormals = 3 , EGBufferFormat::Force16BitsPerChannel = 5 UMETA(DisplayName = "Force 16 Bits Per Channel") }

enum	EMobileLocalLightSetting : int { UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") }

enum	ETrailWidthMode : int { UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") }

enum	EParticleCollisionMode::Type : int { EParticleCollisionMode::UMETA =(DisplayName="Scene Depth") , EParticleCollisionMode::UMETA =(DisplayName="Scene Depth") }

enum	EMaterialShadingModel : int { UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , MSM_MAX }

enum	ESubstrateShadingModel : int { SSM_Unlit , SSM_DefaultLit , SSM_ThinTranslucent , SSM_SubsurfaceMFP , SSM_SubsurfaceProfile , SSM_SubsurfaceWrap , SSM_SubsurfaceThinTwoSided , SSM_VolumetricFogCloud , SSM_Hair , SSM_Eye , SSM_Cloth , SSM_ClearCoat , SSM_SingleLayerWater , SSM_LightFunction , SSM_PostProcess , SSM_Decal , SSM_UI , SSM_NUM }

enum	EMaterialSamplerType : int { UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , SAMPLERTYPE_MAX }

enum	EMaterialStencilCompare : int { UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") }

enum	EMaterialShadingRate : int { UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") }

enum	ELightingBuildQuality : int { UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") }

enum	EMovementMode : int { UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") }

enum class	ENetworkSmoothingMode : uint8 { UMETA =(DisplayName="Disabled") , UMETA =(DisplayName="Linear") , UMETA =(DisplayName="Exponential") }

enum	{ NumExtraFilterBits = 6 }

enum	ECollisionChannel : int { UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , ECC_MAX }

enum	EOverlapFilterOption : int { UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") }

enum	EObjectTypeQuery : int { UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") }

enum	ETraceTypeQuery : int { UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") }

enum	ECollisionResponse : int { UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , ECR_MAX }

enum	EFilterInterpolationType : int { UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , BSIT_MAX }

enum	EWorldType::Type { EWorldType::None , EWorldType::Game , EWorldType::Editor , EWorldType::PIE , EWorldType::EditorPreview , EWorldType::GamePreview , EWorldType::GameRPC , EWorldType::Inactive }

enum class	EFlushLevelStreamingType : uint8 { None , Full , Visibility }

enum	ETimelineSigType : int { ETS_EventSignature , ETS_FloatSignature , ETS_VectorSignature , ETS_LinearColorSignature , ETS_InvalidSignature , ETS_MAX }

enum	ECollisionEnabled::Type : int { ECollisionEnabled::UMETA =(DisplayName="No Collision") , ECollisionEnabled::UMETA =(DisplayName="No Collision") , ECollisionEnabled::UMETA =(DisplayName="No Collision") , ECollisionEnabled::UMETA =(DisplayName="No Collision") , ECollisionEnabled::UMETA =(DisplayName="No Collision") , ECollisionEnabled::UMETA =(DisplayName="No Collision") }

enum class	ESleepEvent : uint8 { SET_Wakeup , SET_Sleep }

enum	ELightMapPaddingType : int { LMPT_NormalPadding , LMPT_PrePadding , LMPT_NoPadding }

enum	EShadowMapFlags : int { SMF_None = 0 , SMF_Streamed = 0x00000001 }

enum class	ETeleportType : uint8 { None , TeleportPhysics , ResetPhysics }

enum class	EUpdateRateShiftBucket : uint8 { ShiftBucket0 = 0 , ShiftBucket1 , ShiftBucket2 , ShiftBucket3 , ShiftBucket4 , ShiftBucket5 , ShiftBucketMax }

enum class	ENaniteGenerateFallback : uint8 { PlatformDefault , Enabled }

enum class	ENaniteFallbackTarget : uint8 { Auto , PercentTriangles , RelativeError }

enum class	ENaniteShapePreservation : uint8 { None , PreserveArea , Voxelize }

enum	ENetRole : int { UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") }

enum	ENetDormancy : int { UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") }

enum class	EPhysicsReplicationMode : uint8 { UMETA =(DisplayName = "Default") , UMETA =(DisplayName = "Predictive Interpolation (WIP)") , UMETA =(DisplayName = "Resimulation (WIP)") }

enum	EAutoReceiveInput::Type : int { EAutoReceiveInput::Disabled , EAutoReceiveInput::Player0 , EAutoReceiveInput::Player1 , EAutoReceiveInput::Player2 , EAutoReceiveInput::Player3 , EAutoReceiveInput::Player4 , EAutoReceiveInput::Player5 , EAutoReceiveInput::Player6 , EAutoReceiveInput::Player7 }

enum class	EAutoPossessAI : uint8 { Disabled , PlacedInWorld , Spawned , PlacedInWorldOrSpawned }

enum	EEndPlayReason::Type : int { EEndPlayReason::Destroyed , EEndPlayReason::LevelTransition , EEndPlayReason::EndPlayInEditor , EEndPlayReason::RemovedFromWorld , EEndPlayReason::Quit }

enum	EWalkableSlopeBehavior : int { UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") , UMETA =(DisplayName="Maintain Y-Axis FOV") }

enum	EPhysicalMaterialMaskColor::Type : int { EPhysicalMaterialMaskColor::Red , EPhysicalMaterialMaskColor::Green , EPhysicalMaterialMaskColor::Blue , EPhysicalMaterialMaskColor::Cyan , EPhysicalMaterialMaskColor::Magenta , EPhysicalMaterialMaskColor::Yellow , EPhysicalMaterialMaskColor::White , EPhysicalMaterialMaskColor::Black , EPhysicalMaterialMaskColor::MAX }

enum	EComponentMobility::Type : int { EComponentMobility::Static , EComponentMobility::Stationary , EComponentMobility::Movable }

enum	EComponentSocketType::Type : int { EComponentSocketType::Invalid , EComponentSocketType::Bone , EComponentSocketType::Socket }

enum class	ESpawnActorCollisionHandlingMethod : uint8 { UMETA =(DisplayName = "Default") , UMETA =(DisplayName = "Always Spawn, Ignore Collisions") , UMETA =(DisplayName = "Try To Adjust Location, But Always Spawn") , UMETA =(DisplayName = "Try To Adjust Location, Don't Spawn If Still Colliding") , UMETA =(DisplayName = "Do Not Spawn") }

enum class	EUserActivityContext : uint8 { Game , Editor , Other }

enum class	EMeshBufferAccess : uint8 { Default , ForceCPUAndGPU }

enum class	ELevelCollectionType : uint8 { DynamicSourceLevels , DynamicDuplicatedLevels , StaticLevels , MAX }

enum class	EPackageAutoSaveType : uint8 { None = 0 , Transient = 1 << 0 , Persistent = 1 << 1 , Any = Transient \| Persistent }

Functions
uint8	GetLightingChannelMaskForStruct (FLightingChannels Value)

uint8	GetDefaultLightingChannelMask ()

int32	GetFirstLightingChannelFromMask (uint8 Mask)

bool	IsVirtualSamplerType (EMaterialSamplerType Value)

	DECLARE_DELEGATE_OneParam (FOnConstraintBroken, int32)

	DECLARE_DELEGATE_ThreeParams (FOnConstraintViolated, int32, float, float)

	DECLARE_DELEGATE_OneParam (FOnPlasticDeformation, int32)

ENGINE_API const TCHAR *	LexToString (const EWorldType::Type Value)

FCollisionEnabledMask ENGINE_API	operator& (const ECollisionEnabled::Type A, const ECollisionEnabled::Type B)

FCollisionEnabledMask ENGINE_API	operator& (const ECollisionEnabled::Type A, const FCollisionEnabledMask B)

FCollisionEnabledMask ENGINE_API	operator\| (const ECollisionEnabled::Type A, const ECollisionEnabled::Type B)

FCollisionEnabledMask ENGINE_API	operator\| (const ECollisionEnabled::Type A, const FCollisionEnabledMask B)

bool	CollisionEnabledHasPhysics (ECollisionEnabled::Type CollisionEnabled)

bool	CollisionEnabledHasQuery (ECollisionEnabled::Type CollisionEnabled)

bool	CollisionEnabledHasProbe (ECollisionEnabled::Type CollisionEnabled)

ECollisionEnabled::Type	CollisionEnabledIntersection (ECollisionEnabled::Type CollisionEnabledA, ECollisionEnabled::Type CollisionEnabledB)

ECollisionEnabled::Type	CollisionEnabledFromFlags (const bool bQuery, const bool bPhysics, const bool bProbe)

void	CollisionEnabledToFlags (const ECollisionEnabled::Type CollisionEnabled, bool &bQuery, bool &bPhysics, bool &bProbe)

ETeleportType	TeleportFlagToEnum (bool bTeleport)

bool	TeleportEnumToFlag (ETeleportType Teleport)

uint32	GetTypeHash (const FBaseComponentReference &Reference)

	DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam (FConstraintBrokenSignature, int32, ConstraintIndex)

	DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam (FPlasticDeformationEventSignature, int32, ConstraintIndex)

	ENUM_CLASS_FLAGS (EPackageAutoSaveType)

Macro Definition Documentation

◆ COLLISION_GIZMO

#define COLLISION_GIZMO ECC_EngineTraceChannel1

◆ NUM_LIGHTING_CHANNELS

#define NUM_LIGHTING_CHANNELS 3

Maximum number of custom lighting channels

◆ SUBSTRATE_TREE_MAX_DEPTH

#define SUBSTRATE_TREE_MAX_DEPTH 48

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Default number of components to expect in TInlineAllocators used with AActor component arrays. Used by engine code to try to avoid allocations in AActor::GetComponents(), among others.

Enumerator
NumInlinedActorComponents

◆ anonymous enum

anonymous enum

Enumerator
NumExtraFilterBits

◆ EAspectRatioAxisConstraint

enum EAspectRatioAxisConstraint : int

Enum describing how to constrain perspective view port FOV

Enumerator
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
AspectRatio_MAX

◆ EAttachmentRule

enum class EAttachmentRule : uint8

strong

Rules for attaching components - needs to be kept synced to EDetachmentRule

Enumerator
KeepRelative	Keeps current relative transform as the relative transform to the new parent.
KeepWorld	Automatically calculates the relative transform such that the attached component maintains the same world transform.
SnapToTarget	Snaps transform to the attach point

◆ EAutoPossessAI

enum class EAutoPossessAI : uint8

strong

Specifies if an AI pawn will automatically be possessed by an AI controller

Enumerator
Disabled	Feature is disabled (do not automatically possess AI).
PlacedInWorld	Only possess by an AI Controller if Pawn is placed in the world.
Spawned	Only possess by an AI Controller if Pawn is spawned after the world has loaded.
PlacedInWorldOrSpawned	Pawn is automatically possessed by an AI Controller whenever it is created.

◆ EBlendMode

enum EBlendMode : int

The blending mode for materials

Warning: This is mirrored in Lightmass, be sure to update the blend mode structure and logic there if this changes.; Check UMaterialInstance::Serialize if changed!!

Enumerator
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
BLEND_TranslucentGreyTransmittance
BLEND_ColoredTransmittanceOnly

◆ ECollisionChannel

enum ECollisionChannel : int

Enum indicating different type of objects for rigid-body collision purposes.

Enumerator
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
ECC_MAX

◆ ECollisionResponse

enum ECollisionResponse : int

Enum indicating how each type should respond

Enumerator
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
ECR_MAX

◆ EDetachmentRule

enum class EDetachmentRule : uint8

strong

Rules for detaching components - needs to be kept synced to EAttachmentRule

Enumerator
KeepRelative	Keeps current relative transform.
KeepWorld	Automatically calculates the relative transform such that the detached component maintains the same world transform.

◆ EFilterInterpolationType

enum EFilterInterpolationType : int

Interpolation method used by animation blending

Enumerator
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
BSIT_MAX

◆ EFlushLevelStreamingType

enum class EFlushLevelStreamingType : uint8

strong

Describes what parts of level streaming should be forcibly handled immediately

Enumerator
None	Do not flush state on change
Full	Allow multiple load requests
Visibility	Flush visibility only, do not allow load requests, flushes async loading as well

◆ EIndirectLightingCacheQuality

enum EIndirectLightingCacheQuality : int

Quality of indirect lighting for Movable primitives. This has a large effect on Indirect Lighting Cache update time.

Enumerator
ILCQ_Off	The indirect lighting cache will be disabled for this object, so no GI from stationary lights on movable objects.
ILCQ_Point	A single indirect lighting sample computed at the bounds origin will be interpolated which fades over time to newer results.
ILCQ_Volume	The object will get a 5x5x5 stable volume of interpolated indirect lighting, which allows gradients of lighting intensity across the receiving object.

◆ ELevelCollectionType

enum class ELevelCollectionType : uint8

strong

Indicates the type of a level collection, used in FLevelCollection.

Enumerator
DynamicSourceLevels	The dynamic levels that are used for normal gameplay and the source for any duplicated collections. Will contain a world's persistent level and any streaming levels that contain dynamic or replicated gameplay actors. This collection will always exist for gameplay and editor worlds.
DynamicDuplicatedLevels	Gameplay relevant levels that have been duplicated from DynamicSourceLevels if requested by the game. This collection only exists if levels have actually been duplicated.
StaticLevels	These levels are shared between the source levels and the duplicated levels, and should contain only static geometry and other visuals that are not replicated or affected by gameplay. These will not be duplicated in order to save memory. If s.World.CreateStaticLevelCollection is 0, this will not be created and static levels will be treated as dynamic.
MAX

◆ ELightingBuildQuality

enum ELightingBuildQuality : int

Lighting build quality enumeration

Enumerator
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.

◆ ELightMapPaddingType

enum ELightMapPaddingType : int

Method for padding a light map in memory

Enumerator
LMPT_NormalPadding
LMPT_PrePadding
LMPT_NoPadding

◆ ELightmapType

enum class ELightmapType : uint8

strong

Type of lightmap that is used for primitive components

Enumerator
Default	Use the default based on Mobility: Surface Lightmap for Static components, Volumetric Lightmap for Movable components.
ForceSurface	Force Surface Lightmap, even if the component moves, which should otherwise change the lighting. This is only supported on components which support surface lightmaps, like static meshes.
ForceVolumetric	Force Volumetric Lightmaps, even if the component is static and could have supported surface lightmaps. Volumetric Lightmaps have better directionality and no Lightmap UV seams, but are much lower resolution than Surface Lightmaps and frequently have self-occlusion and leaking problems. Note: Lightmass currently requires valid lightmap UVs and sufficient lightmap resolution to compute bounce lighting, even though the Volumetric Lightmap will be used at runtime.

◆ EMaterialFloatPrecisionMode

enum EMaterialFloatPrecisionMode : int

The default float precision for material's pixel shaders on mobile devices

Enumerator
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
MFPM_MAX

◆ EMaterialSamplerType

enum EMaterialSamplerType : int

Describes how textures are sampled for materials

Enumerator
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
SAMPLERTYPE_MAX

◆ EMaterialShadingModel

enum EMaterialShadingModel : int

Specifies the overal rendering/shading model for a material

Warning: Check UMaterialInstance::Serialize if changed!

Enumerator
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
MSM_MAX

◆ EMaterialShadingRate

enum EMaterialShadingRate : int

Enumerator
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.

◆ EMaterialStencilCompare

enum EMaterialStencilCompare : int

Enumerator
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.
UMETA	Uses project based precision mode setting Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf All the floats are full-precision Half precision, except explict 'float' in .ush/.usf Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number. Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group. Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group. Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account. Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space. Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance. Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported. Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal. With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color. By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading. Refraction is disabled. Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water. This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON. This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage. This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector). PDO is applied along the Camera Vector for Depth and World Position altogether. Number of unique shading models. Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin. None (movement is disabled). Walking on a surface. Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions. Falling under the effects of gravity, such as after jumping or walking off the edge of a surface. Swimming through a fluid volume, under the effects of gravity and buoyancy. Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction. User-defined custom movement mode, including many possible sub-modes. Reserved for gizmo collision Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below Returns both overlaps with both dynamic and static components returns only overlaps with dynamic actors (far fewer results in practice, much more efficient) returns only overlaps with static actors (fewer results, more efficient) No role at all. Locally simulated proxy of this actor. Locally autonomous proxy of this actor. Authoritative control over the actor. This actor can never go network dormant. This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant. This actor wants to go fully dormant for all connections. This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which. This actor is initially dormant for all connection if it was placed in map. Don't affect the walkable slope. Walkable slope angle will be ignored. Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles. See also FWalkableSlopeOverride::WalkableSlopeAngle Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.

◆ EMeshBufferAccess

enum class EMeshBufferAccess : uint8

strong

Which processors will have access to Mesh Vertex Buffers.

Enumerator
Default	Access will be determined based on the assets used in the mesh and hardware / software capability.
ForceCPUAndGPU	Force access on both CPU and GPU.

◆ EMobileLocalLightSetting

enum EMobileLocalLightSetting : int

Enumerates available MobileLocalLightSetting.

Warning: When this enum is updated please update CVarMobileForwardEnableLocalLights comments

Enumerator

UMETA

Uses project based precision mode setting

Force full-precision for MaterialFloat only, no effect on shader codes in .ush/.usf

All the floats are full-precision

Half precision, except explict 'float' in .ush/.usf

Get the sampler from the texture. Every unique texture will consume a sampler slot, which are limited in number.

Shared sampler source that does not consume a sampler slot. Uses wrap addressing and gets filter mode from the world texture group.

Shared sampler source that does not consume a sampler slot. Uses clamp addressing and gets filter mode from the world texture group.

Shared sampler source that does not consume a sampler slot, used to sample the terrain weightmap. Gets filter mode from the terrain weightmap texture group.

Lighting will be calculated for a volume, without directionality. Use this on particle effects like smoke and dust. This is the cheapest per-pixel lighting method, however the material normal is not taken into account.

Lighting will be calculated for a volume, with directionality so that the normal of the material is taken into account. Note that the default particle tangent space is facing the camera, so enable bGenerateSphericalParticleNormals to get a more useful tangent space.

Same as Volumetric Non Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance.

Same as Volumetric Directional, but lighting is only evaluated at vertices so the pixel shader cost is significantly less. Note that lighting still comes from a volume texture, so it is limited in range. Directional lights become unshadowed in the distance.

Lighting will be calculated for a surface. The light is accumulated in a volume so the result is blurry, limited distance but the per pixel cost is very low. Use this on translucent surfaces like glass and water. Only diffuse lighting is supported.

Lighting will be calculated for a surface. Use this on translucent surfaces like glass and water. This is implemented with forward shading so specular highlights from local lights are supported, however many deferred-only features are not. This is the most expensive translucency lighting method as each light's contribution is computed per-pixel.

Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the Refraction material input.
The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water.

By default, when the root node refraction pin is unplugged, no refraction will appear. The refraction offset into Scene Color is computed based on the difference between the per-pixel normal and the per-vertex normal.
With this mode, a material whose normal is the default (0, 0, 1) will never cause any refraction. This mode is only valid with tangent space normals. The refraction material input scales the offset, although a value of 1.0 maps to no refraction, and a value of 2 maps to a scale of 1.0 on the offset. This is a non-physical model of refraction but is useful on large refractive surfaces like water, since offsets have to stay small to avoid reading outside scene color.

By default, when the root node refraction pin is unplugged, no refraction will appear. Explicit 2D screen offset. This offset is independent of screen resolution and aspect ratio. The user is in charge of any strength and fading.

Refraction is disabled.

Refraction is computed based on the camera vector entering a medium whose index of refraction is defined by the material IOR evaluated from F0. The new medium's surface is defined by the material's normal. With this mode, a flat plane seen from the side will have a constant refraction offset. This is a physical model of refraction but causes reading outside the scene color texture so is a poor fit for large refractive surfaces like water.

This is the pre-Substrate behavior: coverage is ignored and always 1. When rough refraction is disabled, this is behavior is forced ON.

This is a new behavior available with Substrate when rough refraction are enabled: account for roughness, coverage and depth. This is a more physically based behavior: the background scene will be visible untouched according to (1-coverage), while the blurred version will be visible according to coverage.

This is the legacy mode where PDO is applied differently for Depth (along View Forward) and world position (along Camera Vector).

PDO is applied along the Camera Vector for Depth and World Position altogether.

Number of unique shading models.

Shading model will be determined by the Material Expression Graph, by utilizing the 'Shading Model' MaterialAttribute output pin.

None (movement is disabled).

Walking on a surface.

Simplified walking on navigation data (e.g. navmesh). If GetGenerateOverlapEvents() is true, then we will perform sweeps with each navmesh move. If GetGenerateOverlapEvents() is false then movement is cheaper but characters can overlap other objects without some extra process to repel/resolve their collisions.

Falling under the effects of gravity, such as after jumping or walking off the edge of a surface.

Swimming through a fluid volume, under the effects of gravity and buoyancy.

Flying, ignoring the effects of gravity. Affected by the current physics volume's fluid friction.

User-defined custom movement mode, including many possible sub-modes.

Reserved for gizmo collision

Add new serializeable channels above here (i.e. entries that exist in FCollisionResponseContainer) Add only nonserialized/transient flags below

Returns both overlaps with both dynamic and static components

returns only overlaps with dynamic actors (far fewer results in practice, much more efficient)

returns only overlaps with static actors (fewer results, more efficient)

No role at all.

Locally simulated proxy of this actor.

Locally autonomous proxy of this actor.

Authoritative control over the actor.

This actor can never go network dormant.

This actor can go dormant, but is not currently dormant. Game code will tell it when it go dormant.

This actor wants to go fully dormant for all connections.

This actor may want to go dormant for some connections, GetNetDormancy() will be called to find out which.

This actor is initially dormant for all connection if it was placed in map.

Don't affect the walkable slope. Walkable slope angle will be ignored.

Increase walkable slope. Makes it easier to walk up a surface, by allowing traversal over higher-than-usual angles.

See also: FWalkableSlopeOverride::WalkableSlopeAngle

Decrease walkable slope. Makes it harder to walk up a surface, by restricting traversal to lower-than-usual angles.

See also: FWalkableSlopeOverride::WalkableSlopeAngle

Make surface unwalkable. Note: WalkableSlopeAngle will be ignored.