bool FMaterialEditorUtilities::IsInputVisible(UMaterial* Material, int32 Index)
{
static const auto UseDiffuseSpecularMaterialInputs = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.UseDiffuseSpecularMaterialInputs"));
bool bVisibleUV = true;
if (Index >= 16 && Index <= 23)
{
bVisibleUV = Index - 16 < Material->NumCustomizedUVs;
}
switch( Index )
{
case 0:
case 1:
return (UseDiffuseSpecularMaterialInputs->GetValueOnGameThread() != 0) && !Material->bUseMaterialAttributes;
case 2:
case 3:
case 4:
return (UseDiffuseSpecularMaterialInputs->GetValueOnGameThread() == 0) && !Material->bUseMaterialAttributes;
case 24:
return Material->bUseMaterialAttributes;
default:
return !Material->bUseMaterialAttributes && bVisibleUV;
}
}
void UConsole::Serialize( const TCHAR* V, ELogVerbosity::Type Verbosity, const class FName& Category )
{
// e.g. UE_LOG(LogConsoleResponse, Display, TEXT("Test"));
static const FName LogConsoleResponse = FName("LogConsoleResponse");
if (Category == LogConsoleResponse)
{
// log all LogConsoleResponse
OutputText(V);
}
else
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("con.MinLogVerbosity"));
if(CVar)
{
int MinVerbosity = CVar->GetValueOnGameThread();
if((int)Verbosity <= MinVerbosity)
{
// log all that is >= the specified verbosity
OutputText(V);
}
}
}
}
void FConsoleOutputDevice::Serialize(const TCHAR* Text, ELogVerbosity::Type Verbosity, const class FName& Category)
{
FStringOutputDevice::Serialize(Text, Verbosity, Category);
FStringOutputDevice::Serialize(TEXT("\n"), Verbosity, Category);
GLog->Serialize(Text, Verbosity, Category);
if( Console != NULL )
{
bool bLogToConsole = true;
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("con.MinLogVerbosity"));
if(CVar)
{
int MinVerbosity = CVar->GetValueOnGameThread();
if((int)Verbosity <= MinVerbosity)
{
// in case the cvar is used we don't need this printout (avoid double print)
bLogToConsole = false;
}
}
if(bLogToConsole)
{
Console->OutputText(Text);
}
}
}
void UGameUserSettings::ValidateSettings()
{
// Should we wipe all user settings?
if ( !IsVersionValid() )
{
// First try loading the settings, if they haven't been loaded before.
LoadSettings(true);
// If it still an old version, delete the user settings file and reload defaults.
if ( !IsVersionValid() )
{
// Force reset if there aren't any default .ini settings.
SetToDefaults();
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.VSync"));
SetVSyncEnabled( CVar->GetValueOnGameThread() != 0 );
IFileManager::Get().Delete( *GGameUserSettingsIni );
LoadSettings(true);
}
}
if ( ResolutionSizeX <= 0 || ResolutionSizeY <= 0 )
{
SetScreenResolution(FIntPoint(GSystemResolution.ResX, GSystemResolution.ResY));
// Set last confirmed video settings
LastConfirmedFullscreenMode = FullscreenMode;
LastUserConfirmedResolutionSizeX = ResolutionSizeX;
LastUserConfirmedResolutionSizeY = ResolutionSizeY;
}
// The user settings have now been validated for the current version.
UpdateVersion();
}
FDeferredShadingSceneRenderer::FDeferredShadingSceneRenderer(const FSceneViewFamily* InViewFamily,FHitProxyConsumer* HitProxyConsumer)
: FSceneRenderer(InViewFamily, HitProxyConsumer)
, EarlyZPassMode(DDM_NonMaskedOnly)
, TranslucentSelfShadowLayout(0, 0, 0, 0)
, CachedTranslucentSelfShadowLightId(INDEX_NONE)
{
if (FPlatformProperties::SupportsWindowedMode())
{
// Use a depth only pass if we are using full blown HQ lightmaps
// Otherwise base pass pixel shaders will be cheap and there will be little benefit to rendering a depth only pass
if (AllowHighQualityLightmaps() || !ViewFamily.EngineShowFlags.Lighting)
{
EarlyZPassMode = DDM_None;
}
}
// Shader complexity requires depth only pass to display masked material cost correctly
if (ViewFamily.EngineShowFlags.ShaderComplexity)
{
EarlyZPassMode = DDM_AllOccluders;
}
// developer override, good for profiling, can be useful as project setting
{
static const auto ICVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.EarlyZPass"));
const int32 CVarValue = ICVar->GetValueOnGameThread();
switch(CVarValue)
{
case 0: EarlyZPassMode = DDM_None; break;
case 1: EarlyZPassMode = DDM_NonMaskedOnly; break;
case 2: EarlyZPassMode = DDM_AllOccluders; break;
}
}
}
float UGameEngine::GetMaxTickRate(float DeltaTime, bool bAllowFrameRateSmoothing) const
{
float MaxTickRate = 0.f;
if (FPlatformProperties::SupportsWindowedMode() == false && !IsRunningDedicatedServer())
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.VSync"));
// Limit framerate on console if VSYNC is enabled to avoid jumps from 30 to 60 and back.
if( CVar->GetValueOnGameThread() != 0 )
{
if (SmoothedFrameRateRange.HasUpperBound())
{
MaxTickRate = SmoothedFrameRateRange.GetUpperBoundValue();
}
}
}
else
{
UWorld* World = NULL;
for (int32 WorldIndex = 0; WorldIndex < WorldList.Num(); ++WorldIndex)
{
if (WorldList[WorldIndex].WorldType == EWorldType::Game)
{
World = WorldList[WorldIndex].World();
break;
}
}
if( World )
{
UNetDriver* NetDriver = World->GetNetDriver();
// In network games, limit framerate to not saturate bandwidth.
if( NetDriver && (NetDriver->GetNetMode() == NM_DedicatedServer || (NetDriver->GetNetMode() == NM_ListenServer && NetDriver->bClampListenServerTickRate)))
{
// We're a dedicated server, use the LAN or Net tick rate.
MaxTickRate = FMath::Clamp( NetDriver->NetServerMaxTickRate, 10, 120 );
}
/*else if( NetDriver && NetDriver->ServerConnection )
{
if( NetDriver->ServerConnection->CurrentNetSpeed <= 10000 )
{
MaxTickRate = FMath::Clamp( MaxTickRate, 10.f, 90.f );
}
}*/
}
}
// See if the code in the base class wants to replace this
float SuperTickRate = Super::GetMaxTickRate(DeltaTime, bAllowFrameRateSmoothing);
if(SuperTickRate != 0.0)
{
MaxTickRate = SuperTickRate;
}
return MaxTickRate;
}
bool UGameUserSettings::IsVSyncDirty() const
{
bool bIsDirty = false;
if ( GEngine && GEngine->GameViewport && GEngine->GameViewport->ViewportFrame )
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.VSync"));
bIsDirty = (bUseVSync != (CVar->GetValueOnGameThread() != 0));
}
return bIsDirty;
}
int32 UTKMathFunctionLibrary::GetConsoleVariableInt(FString VariableName)
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(*VariableName);
if (CVar)
{
return CVar->GetValueOnGameThread();
//return CVar->GetValueOnAnyThread();
}
return 0;
}
static bool IsEditorCompositingMSAAEnabled(ERHIFeatureLevel::Type InFeatureLevel)
{
bool Ret = false;
if (InFeatureLevel >= ERHIFeatureLevel::SM5)
{
// only supported on SM5 yet
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.MSAA.CompositingSampleCount"));
Ret = CVar->GetValueOnGameThread() > 1;
}
return Ret;
}
void FSteamVRHMD::CalculateRenderTargetSize(const class FViewport& Viewport, uint32& InOutSizeX, uint32& InOutSizeY)
{
check(IsInGameThread());
// if (Flags.bScreenPercentageEnabled)
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataFloat(TEXT("r.ScreenPercentage"));
float value = CVar->GetValueOnGameThread();
if (value > 0.0f)
{
InOutSizeX = FMath::CeilToInt(InOutSizeX * value / 100.f);
InOutSizeY = FMath::CeilToInt(InOutSizeY * value / 100.f);
}
}
}
bool UParticleModuleCollisionGPU::IsValidForLODLevel(UParticleLODLevel* LODLevel, FString& OutErrorString)
{
UMaterialInterface* Material = NULL;
if (LODLevel && LODLevel->RequiredModule)
{
Material = LODLevel->RequiredModule->Material;
}
if (Material == NULL)
{
Material = UMaterial::GetDefaultMaterial(MD_Surface);
}
check(Material);
EBlendMode BlendMode = BLEND_Opaque;
const FMaterialResource* MaterialResource = Material->GetMaterialResource(GetWorld() ? GetWorld()->FeatureLevel : GMaxRHIFeatureLevel);
if(MaterialResource)
{
BlendMode = MaterialResource->GetBlendMode();
}
if (CollisionMode == EParticleCollisionMode::SceneDepth && (BlendMode == BLEND_Opaque || BlendMode == BLEND_Masked))
{
OutErrorString = NSLOCTEXT("UnrealEd", "CollisionOnOpaqueEmitter", "Scene depth collision cannot be used on emitters with an opaque material.").ToString();
return false;
}
if (CollisionMode == EParticleCollisionMode::DistanceField)
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.GenerateMeshDistanceFields"));
if (CVar->GetValueOnGameThread() == 0)
{
OutErrorString = NSLOCTEXT("UnrealEd", "CollisionWithoutDistanceField", "Distance Field collision requires the 'Generate Mesh Distance Fields' Renderer project setting to be enabled.").ToString();
return false;
}
}
if (LODLevel->TypeDataModule && LODLevel->TypeDataModule->IsA(UParticleModuleTypeDataGpu::StaticClass()))
{
if(!IsDistributionAllowedOnGPU(ResilienceScaleOverLife.Distribution))
{
OutErrorString = GetDistributionNotAllowedOnGPUText(StaticClass()->GetName(), "ResilienceScaleOverLife" ).ToString();
return false;
}
}
return true;
}
int32 ShooterGameGetBoundFullScreenModeCVar()
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.FullScreenMode"));
if (FPlatformProperties::SupportsWindowedMode())
{
int32 Value = CVar->GetValueOnGameThread();
if(Value >= 0 && Value <= 2)
{
return Value;
}
}
// every other value behaves like 0
return 0;
}
bool FCascadeEdPreviewViewportClient::InputAxis(FViewport* Viewport, int32 ControllerId, FKey Key, float Delta, float DeltaTime, int32 NumSamples, bool bGamepad)
{
bool bHandled = false;
if (bManipulatingVectorField)
{
UParticleModuleVectorFieldLocal* VectorFieldModule = Cast<UParticleModuleVectorFieldLocal>(CascadePtr.Pin()->GetSelectedModule());
if (VectorFieldModule)
{
const float MoveX = ((Key == EKeys::MouseX) ? Delta : 0.0f) * DragX;
const float MoveY = ((Key == EKeys::MouseY) ? Delta : 0.0f) * DragY;
const float MoveAmount = MoveX + MoveY;
VectorFieldModule->PreEditChange(NULL);
if (WidgetMM == WMM_Translate)
{
VectorFieldModule->RelativeTranslation += (LocalManipulateDir * MoveAmount * CVarCascadeDragSpeed.GetValueOnGameThread());
}
else if (WidgetMM == WMM_Rotate)
{
const FQuat CurrentRotation = VectorFieldModule->RelativeRotation.Quaternion();
const FQuat DeltaRotation(LocalManipulateDir, -MoveAmount * CVarCascadeRotateSpeed.GetValueOnGameThread());
const FQuat NewRotation = CurrentRotation * DeltaRotation;
VectorFieldModule->RelativeRotation = FRotator(NewRotation);
}
else if (WidgetMM == WMM_Scale)
{
VectorFieldModule->RelativeScale3D += (LocalManipulateDir * MoveAmount * CVarCascadeScaleSpeed.GetValueOnGameThread());
}
VectorFieldModule->PostEditChange();
}
bHandled = true;
}
else
{
bHandled = FEditorViewportClient::InputAxis(Viewport,ControllerId,Key,Delta,DeltaTime,NumSamples,bGamepad);
}
if (!IsRealtime() && !FMath::IsNearlyZero(Delta))
{
Viewport->Invalidate();
}
return bHandled;
}
void UGripMotionControllerComponent::FViewExtension::BeginRenderViewFamily(FSceneViewFamily& InViewFamily)
{
if (!MotionControllerComponent)
{
return;
}
FScopeLock ScopeLock(&CritSect);
if (MotionControllerComponent->bDisableLowLatencyUpdate || !CVarEnableMotionControllerLateUpdate->GetValueOnGameThread())
{
return;
}
LateUpdatePrimitives.Reset();
GatherLateUpdatePrimitives(MotionControllerComponent, LateUpdatePrimitives);
// Loop through gripped actors
for (FBPActorGripInformation actor : MotionControllerComponent->GrippedActors)
{
// Attached actors will already register as is above, so skipping GripWithAttachTo actors
if (actor.bTurnOffLateUpdateWhenColliding && actor.bColliding)
continue;
if (actor.Actor)
{
// Get primitive components attached to the actor and update them with the late motion controller offset
TInlineComponentArray<UPrimitiveComponent*> PrimComps(actor.Actor);
for (UPrimitiveComponent * PrimitiveComponent : PrimComps)
{
GatherLateGripUpdatePrimitives(PrimitiveComponent, LateUpdatePrimitives);
}
}
else if (actor.Component)
{
GatherLateGripUpdatePrimitives(actor.Component, LateUpdatePrimitives);
}
}
}
void UGameUserSettings::ResetToCurrentSettings()
{
if ( GEngine && GEngine->GameViewport && GEngine->GameViewport->GetWindow().IsValid() )
{
//handle the fullscreen setting
SetFullscreenMode(GetWindowModeType(GEngine->GameViewport->GetWindow()->GetWindowMode()));
//set the current resolution
SetScreenResolution(FIntPoint(GSystemResolution.ResX, GSystemResolution.ResY));
// Set the current VSync state
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.VSync"));
SetVSyncEnabled( CVar->GetValueOnGameThread() != 0 );
// Reset to confirmed settings
FullscreenMode = LastConfirmedFullscreenMode;
ResolutionSizeX = LastUserConfirmedResolutionSizeX;
ResolutionSizeY = LastUserConfirmedResolutionSizeY;
// Reset the quality settings to the current levels
ScalabilityQuality = Scalability::GetQualityLevels();
}
}
/**
* Sets bMapNeedsLightingFullyRebuild to the specified value. Marks the worldsettings package dirty if the value changed.
*
* @param bInMapNeedsLightingFullyRebuild The new value.
*/
void UWorld::SetMapNeedsLightingFullyRebuilt(int32 InNumLightingUnbuiltObjects)
{
static const auto AllowStaticLightingVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.AllowStaticLighting"));
const bool bAllowStaticLighting = (!AllowStaticLightingVar || AllowStaticLightingVar->GetValueOnGameThread() != 0);
AWorldSettings* WorldSettings = GetWorldSettings();
if (bAllowStaticLighting && WorldSettings && !WorldSettings->bForceNoPrecomputedLighting)
{
check(IsInGameThread());
if (NumLightingUnbuiltObjects != InNumLightingUnbuiltObjects && (NumLightingUnbuiltObjects == 0 || InNumLightingUnbuiltObjects == 0))
{
// Save the lighting invalidation for transactions.
Modify(false);
}
NumLightingUnbuiltObjects = InNumLightingUnbuiltObjects;
// Update last time unbuilt lighting was encountered.
if (NumLightingUnbuiltObjects > 0)
{
LastTimeUnbuiltLightingWasEncountered = FApp::GetCurrentTime();
}
}
}
void FPlatformerOptions::FullScreenOptionChanged(TSharedPtr<FGameMenuItem> MenuItem, int32 MultiOptionIndex)
{
static auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.FullScreenMode"));
auto FullScreenMode = CVar->GetValueOnGameThread() == 1 ? EWindowMode::WindowedFullscreen : EWindowMode::Fullscreen;
bFullScreenOpt = MultiOptionIndex == 0 ? EWindowMode::Windowed : FullScreenMode;
}
void ShaderMapAppendKeyString(EShaderPlatform Platform, FString& KeyString)
{
// Globals that should cause all shaders to recompile when changed must be appended to the key here
// Key should be kept as short as possible while being somewhat human readable for debugging
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("Compat.UseDXT5NormalMaps"));
KeyString += (CVar && CVar->GetValueOnAnyThread() != 0) ? TEXT("_DXTN") : TEXT("_BC5N");
}
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.CompileShadersForDevelopment"));
KeyString += (CVar && CVar->GetValueOnAnyThread() != 0) ? TEXT("_DEV") : TEXT("_NoDEV");
}
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.AllowStaticLighting"));
const bool bValue = CVar ? CVar->GetValueOnAnyThread() != 0 : true;
KeyString += bValue ? TEXT("_SL") : TEXT("_NoSL");
}
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.BasePassOutputsVelocity"));
if (CVar && CVar->GetValueOnGameThread() != 0)
{
KeyString += TEXT("_GV");
}
}
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.GBuffer"));
if (CVar ? CVar->GetValueOnAnyThread() == 0 : false)
{
KeyString += TEXT("_NoGB");
}
}
{
static IConsoleVariable* CVar = IConsoleManager::Get().FindConsoleVariable(TEXT("r.DBuffer"));
KeyString += (CVar && CVar->GetInt() != 0) ? TEXT("_DBuf") : TEXT("_NoDBuf");
}
{
static const auto CVar = IConsoleManager::Get().FindConsoleVariable(TEXT("r.Shaders.KeepDebugInfo"));
KeyString += (CVar && CVar->GetInt() != 0) ? TEXT("_NoStrip") : TEXT("");
}
{
static const auto CVar = IConsoleManager::Get().FindConsoleVariable(TEXT("r.Shaders.Optimize"));
KeyString += (CVar && CVar->GetInt() != 0) ? TEXT("") : TEXT("_NoOpt");
}
if( Platform == SP_PS4 )
{
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.PS4MixedModeShaderDebugInfo"));
if (CVar && CVar->GetValueOnAnyThread() != 0)
{
KeyString += TEXT("_MMDBG");
}
}
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.PS4DumpShaderSDB"));
if (CVar && CVar->GetValueOnAnyThread() != 0)
{
KeyString += TEXT("_SDB");
}
}
}
}
FSceneView::FSceneView(const FSceneViewInitOptions& InitOptions)
: Family(InitOptions.ViewFamily)
, State(InitOptions.SceneViewStateInterface)
, ViewActor(InitOptions.ViewActor)
, Drawer(InitOptions.ViewElementDrawer)
, ViewRect(InitOptions.GetConstrainedViewRect())
, UnscaledViewRect(InitOptions.GetConstrainedViewRect())
, UnconstrainedViewRect(InitOptions.GetViewRect())
, MaxShadowCascades(10)
, WorldToMetersScale(InitOptions.WorldToMetersScale)
, ProjectionMatrixUnadjustedForRHI(InitOptions.ProjectionMatrix)
, BackgroundColor(InitOptions.BackgroundColor)
, OverlayColor(InitOptions.OverlayColor)
, ColorScale(InitOptions.ColorScale)
, StereoPass(InitOptions.StereoPass)
, DiffuseOverrideParameter(FVector4(0,0,0,1))
, SpecularOverrideParameter(FVector4(0,0,0,1))
, NormalOverrideParameter(FVector4(0,0,0,1))
, RoughnessOverrideParameter(FVector2D(0,1))
, HiddenPrimitives(InitOptions.HiddenPrimitives)
, LODDistanceFactor(InitOptions.LODDistanceFactor)
, bCameraCut(InitOptions.bInCameraCut)
, bOriginOffsetThisFrame(InitOptions.bOriginOffsetThisFrame)
, CursorPos(InitOptions.CursorPos)
, bIsGameView(false)
, bForceShowMaterials(false)
, bIsViewInfo(false)
, bIsSceneCapture(false)
, bIsReflectionCapture(false)
, bIsLocked(false)
, bStaticSceneOnly(false)
#if WITH_EDITOR
, OverrideLODViewOrigin(InitOptions.OverrideLODViewOrigin)
, bAllowTranslucentPrimitivesInHitProxy( true )
, bHasSelectedComponents( false )
#endif
, FeatureLevel(InitOptions.ViewFamily ? InitOptions.ViewFamily->GetFeatureLevel() : GMaxRHIFeatureLevel)
{
check(UnscaledViewRect.Min.X >= 0);
check(UnscaledViewRect.Min.Y >= 0);
check(UnscaledViewRect.Width() > 0);
check(UnscaledViewRect.Height() > 0);
ViewMatrices.ViewMatrix = InitOptions.ViewMatrix;
// Adjust the projection matrix for the current RHI.
ViewMatrices.ProjMatrix = AdjustProjectionMatrixForRHI(ProjectionMatrixUnadjustedForRHI);
// Compute the view projection matrix and its inverse.
ViewProjectionMatrix = ViewMatrices.GetViewProjMatrix();
// For precision reasons the view matrix inverse is calculated independently.
InvViewMatrix = ViewMatrices.ViewMatrix.Inverse();
InvViewProjectionMatrix = ViewMatrices.GetInvProjMatrix() * InvViewMatrix;
bool ApplyPreViewTranslation = true;
// Calculate the view origin from the view/projection matrices.
if(IsPerspectiveProjection())
{
ViewMatrices.ViewOrigin = InvViewMatrix.GetOrigin();
}
#if WITH_EDITOR
else if (InitOptions.bUseFauxOrthoViewPos)
{
float DistanceToViewOrigin = WORLD_MAX;
ViewMatrices.ViewOrigin = FVector4(InvViewMatrix.TransformVector(FVector(0,0,-1)).GetSafeNormal()*DistanceToViewOrigin,1) + InvViewMatrix.GetOrigin();
}
#endif
else
{
ViewMatrices.ViewOrigin = FVector4(InvViewMatrix.TransformVector(FVector(0,0,-1)).GetSafeNormal(),0);
// to avoid issues with view dependent effect (e.g. Frensel)
ApplyPreViewTranslation = false;
}
// Translate world-space so its origin is at ViewOrigin for improved precision.
// Note that this isn't exactly right for orthogonal projections (See the above special case), but we still use ViewOrigin
// in that case so the same value may be used in shaders for both the world-space translation and the camera's world position.
if(ApplyPreViewTranslation)
{
ViewMatrices.PreViewTranslation = -FVector(ViewMatrices.ViewOrigin);
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
{
// console variable override
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.PreViewTranslation"));
int32 Value = CVar->GetValueOnGameThread();
static FVector PreViewTranslationBackup;
if(Value)
{
PreViewTranslationBackup = ViewMatrices.PreViewTranslation;
}
else
{
ViewMatrices.PreViewTranslation = PreViewTranslationBackup;
}
}
#endif // !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
}
/** The view transform, starting from world-space points translated by -ViewOrigin. */
FMatrix TranslatedViewMatrix = FTranslationMatrix(-ViewMatrices.PreViewTranslation) * ViewMatrices.ViewMatrix;
// Compute a transform from view origin centered world-space to clip space.
ViewMatrices.TranslatedViewProjectionMatrix = TranslatedViewMatrix * ViewMatrices.ProjMatrix;
ViewMatrices.InvTranslatedViewProjectionMatrix = ViewMatrices.TranslatedViewProjectionMatrix.Inverse();
// Compute screen scale factors.
// Stereo renders at half horizontal resolution, but compute shadow resolution based on full resolution.
const bool bStereo = StereoPass != eSSP_FULL;
const float ScreenXScale = bStereo ? 2.0f : 1.0f;
ViewMatrices.ProjectionScale.X = ScreenXScale * FMath::Abs(ViewMatrices.ProjMatrix.M[0][0]);
ViewMatrices.ProjectionScale.Y = FMath::Abs(ViewMatrices.ProjMatrix.M[1][1]);
ViewMatrices.ScreenScale = FMath::Max(
ViewRect.Size().X * 0.5f * ViewMatrices.ProjectionScale.X,
ViewRect.Size().Y * 0.5f * ViewMatrices.ProjectionScale.Y
);
ShadowViewMatrices = ViewMatrices;
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
{
// console variable override
int32 Value = CVarShadowFreezeCamera.GetValueOnAnyThread();
static FViewMatrices Backup = ShadowViewMatrices;
if(Value)
{
ShadowViewMatrices = Backup;
}
else
{
Backup = ShadowViewMatrices;
}
}
#endif // !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
if (InitOptions.OverrideFarClippingPlaneDistance > 0.0f)
{
const FPlane FarPlane(ViewMatrices.ViewOrigin + GetViewDirection() * InitOptions.OverrideFarClippingPlaneDistance, GetViewDirection());
// Derive the view frustum from the view projection matrix, overriding the far plane
GetViewFrustumBounds(ViewFrustum,ViewProjectionMatrix,FarPlane,true,false);
}
else
{
// Derive the view frustum from the view projection matrix.
GetViewFrustumBounds(ViewFrustum,ViewProjectionMatrix,false);
}
// Derive the view's near clipping distance and plane.
// The GetFrustumFarPlane() is the near plane because of reverse Z projection.
bHasNearClippingPlane = ViewProjectionMatrix.GetFrustumFarPlane(NearClippingPlane);
if(ViewMatrices.ProjMatrix.M[2][3] > DELTA)
{
// Infinite projection with reversed Z.
NearClippingDistance = ViewMatrices.ProjMatrix.M[3][2];
}
else
{
// Ortho projection with reversed Z.
NearClippingDistance = (1.0f - ViewMatrices.ProjMatrix.M[3][2]) / ViewMatrices.ProjMatrix.M[2][2];
}
// Determine whether the view should reverse the cull mode due to a negative determinant. Only do this for a valid scene
bReverseCulling = (Family && Family->Scene) ? FMath::IsNegativeFloat(ViewMatrices.ViewMatrix.Determinant()) : false;
// OpenGL Gamma space output in GLSL flips Y when rendering directly to the back buffer (so not needed on PC, as we never render directly into the back buffer)
auto ShaderPlatform = GShaderPlatformForFeatureLevel[FeatureLevel];
static bool bPlatformRequiresReverseCulling = (IsOpenGLPlatform(ShaderPlatform) && !IsPCPlatform(ShaderPlatform));
static auto* MobileHDRCvar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.MobileHDR"));
check(MobileHDRCvar);
bReverseCulling = (bPlatformRequiresReverseCulling && MobileHDRCvar->GetValueOnAnyThread() == 0) ? !bReverseCulling : bReverseCulling;
// Setup transformation constants to be used by the graphics hardware to transform device normalized depth samples
// into world oriented z.
InvDeviceZToWorldZTransform = CreateInvDeviceZToWorldZTransform(ProjectionMatrixUnadjustedForRHI);
static TConsoleVariableData<int32>* SortPolicyCvar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.TranslucentSortPolicy"));
TranslucentSortPolicy = static_cast<ETranslucentSortPolicy::Type>(SortPolicyCvar->GetValueOnAnyThread());
TranslucentSortAxis = GetDefault<URendererSettings>()->TranslucentSortAxis;
// As the world is only accessable from the game thread, bIsGameView should be explicitly
// set on any other thread.
if(IsInGameThread())
{
bIsGameView = (Family && Family->Scene && Family->Scene->GetWorld() ) ? Family->Scene->GetWorld()->IsGameWorld() : false;
}
#if WITH_EDITOR
EditorViewBitflag = InitOptions.EditorViewBitflag;
SelectionOutlineColor = GEngine->GetSelectionOutlineColor();
#endif
}
void FSlateElementPS::ModifyCompilationEnvironment(EShaderPlatform Platform, FShaderCompilerEnvironment& OutEnvironment)
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.Tonemapper709"));
OutEnvironment.SetDefine(TEXT("USE_709"), CVar ? (CVar->GetValueOnGameThread() != 0) : 1);
}
bool ULightComponent::CanEditChange(const UProperty* InProperty) const
{
if (InProperty)
{
FString PropertyName = InProperty->GetName();
if (PropertyName == GET_MEMBER_NAME_STRING_CHECKED(ULightComponent, bCastShadowsFromCinematicObjectsOnly))
{
return Mobility == EComponentMobility::Movable;
}
if (PropertyName == GET_MEMBER_NAME_STRING_CHECKED(ULightComponent, LightFunctionMaterial)
|| PropertyName == GET_MEMBER_NAME_STRING_CHECKED(ULightComponent, LightFunctionScale)
|| PropertyName == GET_MEMBER_NAME_STRING_CHECKED(ULightComponent, LightFunctionFadeDistance)
|| PropertyName == GET_MEMBER_NAME_STRING_CHECKED(ULightComponent, DisabledBrightness)
|| PropertyName == GET_MEMBER_NAME_STRING_CHECKED(ULightComponent, IESTexture)
|| PropertyName == GET_MEMBER_NAME_STRING_CHECKED(ULightComponent, bUseIESBrightness)
|| PropertyName == GET_MEMBER_NAME_STRING_CHECKED(ULightComponent, IESBrightnessScale))
{
if (Mobility == EComponentMobility::Static)
{
return false;
}
}
const bool bIsRayStartOffset = PropertyName == GET_MEMBER_NAME_STRING_CHECKED(ULightComponent, RayStartOffsetDepthScale);
if (PropertyName == GET_MEMBER_NAME_STRING_CHECKED(ULightComponent, bUseRayTracedDistanceFieldShadows)
|| bIsRayStartOffset)
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.GenerateMeshDistanceFields"));
bool bCanEdit = CastShadows && CastDynamicShadows && Mobility != EComponentMobility::Static && CVar->GetValueOnGameThread() != 0;
if (bIsRayStartOffset)
{
bCanEdit = bCanEdit && bUseRayTracedDistanceFieldShadows;
}
return bCanEdit;
}
if (PropertyName == GET_MEMBER_NAME_STRING_CHECKED(ULightComponent, LightFunctionScale)
|| PropertyName == GET_MEMBER_NAME_STRING_CHECKED(ULightComponent, LightFunctionFadeDistance)
|| PropertyName == GET_MEMBER_NAME_STRING_CHECKED(ULightComponent, DisabledBrightness))
{
return LightFunctionMaterial != NULL;
}
if (PropertyName == TEXT("LightmassSettings"))
{
return Mobility != EComponentMobility::Movable;
}
if (PropertyName == GET_MEMBER_NAME_STRING_CHECKED(ULightComponent, BloomScale)
|| PropertyName == GET_MEMBER_NAME_STRING_CHECKED(ULightComponent, BloomThreshold)
|| PropertyName == GET_MEMBER_NAME_STRING_CHECKED(ULightComponent, BloomTint))
{
return bEnableLightShaftBloom;
}
if (PropertyName == GET_MEMBER_NAME_STRING_CHECKED(ULightComponent, Temperature))
{
return bUseTemperature;
}
}
return Super::CanEditChange(InProperty);
}
void UGameEngine::ConditionallyOverrideSettings(int32& ResolutionX, int32& ResolutionY, EWindowMode::Type& WindowMode)
{
if (FParse::Param(FCommandLine::Get(),TEXT("Windowed")) || FParse::Param(FCommandLine::Get(), TEXT("SimMobile")))
{
// -Windowed or -SimMobile
WindowMode = EWindowMode::Windowed;
}
else if (FParse::Param(FCommandLine::Get(),TEXT("FullScreen")))
{
// -FullScreen
auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.FullScreenMode"));
check(CVar);
WindowMode = CVar->GetValueOnGameThread() == 0 ? EWindowMode::Fullscreen : EWindowMode::WindowedFullscreen;
}
//fullscreen is always supported, but don't allow windowed mode on platforms that dont' support it.
WindowMode = (!FPlatformProperties::SupportsWindowedMode() && (WindowMode == EWindowMode::Windowed || WindowMode == EWindowMode::WindowedMirror || WindowMode == EWindowMode::WindowedFullscreen)) ? EWindowMode::Fullscreen : WindowMode;
FParse::Value(FCommandLine::Get(), TEXT("ResX="), ResolutionX);
FParse::Value(FCommandLine::Get(), TEXT("ResY="), ResolutionY);
if (!IsRunningDedicatedServer() && ((ResolutionX <= 0) || (ResolutionY <= 0)))
{
// consume available desktop area
FDisplayMetrics DisplayMetrics;
FDisplayMetrics::GetDisplayMetrics( DisplayMetrics );
ResolutionX = DisplayMetrics.PrimaryDisplayWidth;
ResolutionY = DisplayMetrics.PrimaryDisplayHeight;
// If we're in windowed mode, attempt to choose a suitable starting resolution that is smaller than the desktop, with a matching aspect ratio
if (WindowMode == EWindowMode::Windowed)
{
TArray<FIntPoint> WindowedResolutions;
GenerateConvenientWindowedResolutions(DisplayMetrics, WindowedResolutions);
if (WindowedResolutions.Num() > 0)
{
// We'll default to the largest one we have
ResolutionX = WindowedResolutions[WindowedResolutions.Num() - 1].X;
ResolutionY = WindowedResolutions[WindowedResolutions.Num() - 1].Y;
// Attempt to find the largest one with the same aspect ratio
float DisplayAspect = (float)DisplayMetrics.PrimaryDisplayWidth / (float)DisplayMetrics.PrimaryDisplayHeight;
for (int32 i = WindowedResolutions.Num() - 1; i >= 0; --i)
{
float Aspect = (float)WindowedResolutions[i].X / (float)WindowedResolutions[i].Y;
if (FMath::Abs(Aspect - DisplayAspect) < KINDA_SMALL_NUMBER)
{
ResolutionX = WindowedResolutions[i].X;
ResolutionY = WindowedResolutions[i].Y;
break;
}
}
}
}
}
// Check the platform to see if we should override the user settings.
if (FPlatformProperties::HasFixedResolution())
{
// Always use the device's actual resolution that has been setup earlier
FDisplayMetrics DisplayMetrics;
FDisplayMetrics::GetDisplayMetrics( DisplayMetrics );
// We need to pass the resolution back out to GameUserSettings, or it will just override it again
ResolutionX = DisplayMetrics.PrimaryDisplayWorkAreaRect.Right - DisplayMetrics.PrimaryDisplayWorkAreaRect.Left;
ResolutionY = DisplayMetrics.PrimaryDisplayWorkAreaRect.Bottom - DisplayMetrics.PrimaryDisplayWorkAreaRect.Top;
FSystemResolution::RequestResolutionChange(ResolutionX, ResolutionY, EWindowMode::Fullscreen);
}
if (FParse::Param(FCommandLine::Get(),TEXT("Portrait")))
{
Swap(ResolutionX, ResolutionY);
}
}
void FPhysScene::InitPhysScene(uint32 SceneType)
{
check(SceneType < NumPhysScenes);
#if WITH_PHYSX
PhysxUserData = FPhysxUserData(this);
// Include scene descriptor in loop, so that we might vary it with scene type
PxSceneDesc PSceneDesc(GPhysXSDK->getTolerancesScale());
PSceneDesc.cpuDispatcher = CPUDispatcher;
PSceneDesc.filterShader = PhysXSimFilterShader;
PSceneDesc.simulationEventCallback = SimEventCallback;
// Set bounce threshold
static const auto CVarBounceThresholdVelocity = IConsoleManager::Get().FindTConsoleVariableDataFloat(TEXT("p.BounceThresholdVelocity"));
PSceneDesc.bounceThresholdVelocity = CVarBounceThresholdVelocity->GetValueOnGameThread();
// Possibly set flags in async scene for better behavior with piles
#if USE_ADAPTIVE_FORCES_FOR_ASYNC_SCENE
if (SceneType == PST_Async)
{
PSceneDesc.flags |= PxSceneFlag::eADAPTIVE_FORCE;
}
#endif
#if USE_SPECIAL_FRICTION_MODEL_FOR_ASYNC_SCENE
if (SceneType == PST_Async)
{
PSceneDesc.flags |= PxSceneFlag::eENABLE_ONE_DIRECTIONAL_FRICTION;
}
#endif
// If we're frame lagging the async scene (truly running it async) then use the scene lock
#if USE_SCENE_LOCK
if (SceneType == PST_Async)
{
PSceneDesc.flags |= PxSceneFlag::eREQUIRE_RW_LOCK;
}
#endif
// We want to use 'active transforms'
PSceneDesc.flags |= PxSceneFlag::eENABLE_ACTIVETRANSFORMS;
// @TODO Should we set up PSceneDesc.limits? How?
// Do this to improve loading times, esp. for streaming in sublevels
PSceneDesc.staticStructure = PxPruningStructure::eDYNAMIC_AABB_TREE;
// Default to rebuilding tree slowly
PSceneDesc.dynamicTreeRebuildRateHint = PhysXSlowRebuildRate;
bool bIsValid = PSceneDesc.isValid();
if(!bIsValid)
{
UE_LOG(LogPhysics, Log, TEXT("Invalid PSceneDesc"));
}
// Create scene, and add to map
PxScene* PScene = GPhysXSDK->createScene(PSceneDesc);
#if WITH_APEX
// Build the APEX scene descriptor for the PhysX scene
NxApexSceneDesc ApexSceneDesc;
ApexSceneDesc.scene = PScene;
// This interface allows us to modify the PhysX simulation filter shader data with contact pair flags
ApexSceneDesc.physX3Interface = &GApexPhysX3Interface;
// Create the APEX scene from our descriptor
NxApexScene* ApexScene = GApexSDK->createScene(ApexSceneDesc);
// This enables debug rendering using the "legacy" method, not using the APEX render API
ApexScene->setUseDebugRenderable(true);
// Allocate a view matrix for APEX scene LOD
ApexScene->allocViewMatrix(physx::ViewMatrixType::LOOK_AT_RH);
// Add the APEX scene to the map instead of the PhysX scene, since we can access the latter through the former
GPhysXSceneMap.Add(PhysXSceneCount, ApexScene);
#else // #if WITH_APEX
GPhysXSceneMap.Add(PhysXSceneCount, PScene);
#endif // #if WITH_APEX
// Lock scene lock, in case it is required
SCENE_LOCK_WRITE(PScene);
// enable CCD at scene level
if(bGlobalCCD)
{
PScene->setFlag(PxSceneFlag::eENABLE_CCD, true);
}
// Need to turn this on to consider kinematics turning into dynamic. Otherwise, you'll need to call resetFiltering to do the expensive broadphase reinserting
PScene->setFlag(PxSceneFlag::eENABLE_KINEMATIC_STATIC_PAIRS, true);
// Unlock scene lock, in case it is required
SCENE_UNLOCK_WRITE(PScene);
// Save pointer to FPhysScene in userdata
PScene->userData = &PhysxUserData;
#if WITH_APEX
ApexScene->userData = &PhysxUserData;
#endif
// Store index of PhysX Scene in this FPhysScene
this->PhysXSceneIndex[SceneType] = PhysXSceneCount;
// Increment scene count
PhysXSceneCount++;
// Only create PhysXVehicleManager in the sync scene
if ( SceneType == PST_Sync )
{
check(VehicleManager == NULL);
VehicleManager = new FPhysXVehicleManager(PScene);
}
#if WITH_SUBSTEPPING
//Initialize substeppers
PhysSubSteppers[SceneType] = new FPhysSubstepTask(PScene);
#endif
#endif // WITH_PHYSX
}
void FSceneView::EndFinalPostprocessSettings(const FSceneViewInitOptions& ViewInitOptions)
{
{
static const auto CVarMobileMSAA = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.MobileMSAA"));
if(CVarMobileMSAA ? CVarMobileMSAA->GetValueOnGameThread() > 1 : false)
{
// Turn off various features which won't work with mobile MSAA.
FinalPostProcessSettings.DepthOfFieldScale = 0.0f;
FinalPostProcessSettings.AntiAliasingMethod = AAM_None;
}
}
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.BloomQuality"));
int Value = CVar->GetValueOnGameThread();
if(Value <= 0)
{
FinalPostProcessSettings.BloomIntensity = 0.0f;
}
}
if(!Family->EngineShowFlags.Bloom)
{
FinalPostProcessSettings.BloomIntensity = 0.0f;
}
if(!Family->EngineShowFlags.GlobalIllumination)
{
FinalPostProcessSettings.LPVIntensity = 0.0f;
}
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.DepthOfFieldQuality"));
int Value = CVar->GetValueOnGameThread();
if(Value <= 0)
{
FinalPostProcessSettings.DepthOfFieldScale = 0.0f;
}
}
if(!Family->EngineShowFlags.DepthOfField)
{
FinalPostProcessSettings.DepthOfFieldScale = 0;
}
if(!Family->EngineShowFlags.Vignette)
{
FinalPostProcessSettings.VignetteIntensity = 0;
FinalPostProcessSettings.VignetteColor = FLinearColor(0.0f, 0.0f, 0.0f);
}
if(!Family->EngineShowFlags.Grain)
{
FinalPostProcessSettings.GrainIntensity = 0;
FinalPostProcessSettings.GrainJitter = 0;
}
if(!Family->EngineShowFlags.CameraImperfections)
{
FinalPostProcessSettings.BloomDirtMaskIntensity = 0;
}
if(!Family->EngineShowFlags.AmbientCubemap)
{
FinalPostProcessSettings.ContributingCubemaps.Empty();
}
if(!Family->EngineShowFlags.LensFlares)
{
FinalPostProcessSettings.LensFlareIntensity = 0;
}
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
{
float Value = CVarExposureOffset.GetValueOnGameThread();
FinalPostProcessSettings.AutoExposureBias += Value;
}
#endif
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataFloat(TEXT("r.ScreenPercentage"));
float Value = CVar->GetValueOnGameThread();
if(Value >= 0.0)
{
FinalPostProcessSettings.ScreenPercentage = Value;
}
}
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
{
float Value = CVarSSRMaxRoughness.GetValueOnGameThread();
if(Value >= 0.0f)
{
FinalPostProcessSettings.ScreenSpaceReflectionMaxRoughness = Value;
}
}
#endif
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataFloat(TEXT("r.AmbientOcclusionStaticFraction"));
float Value = CVar->GetValueOnGameThread();
if(Value >= 0.0)
{
FinalPostProcessSettings.AmbientOcclusionStaticFraction = Value;
}
}
if(!Family->EngineShowFlags.ScreenPercentage || bIsSceneCapture || bIsReflectionCapture)
{
FinalPostProcessSettings.ScreenPercentage = 100;
}
if(!Family->EngineShowFlags.AmbientOcclusion)
{
FinalPostProcessSettings.AmbientOcclusionIntensity = 0;
}
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataFloat(TEXT("r.AmbientOcclusionRadiusScale"));
float Scale = FMath::Clamp(CVar->GetValueOnGameThread(), 0.1f, 5.0f);
FinalPostProcessSettings.AmbientOcclusionRadius *= Scale;
}
{
float Scale = FMath::Clamp(CVarSSAOFadeRadiusScale.GetValueOnGameThread(), 0.01f, 50.0f);
FinalPostProcessSettings.AmbientOcclusionDistance *= Scale;
}
{
float Value = FMath::Clamp(CVarMotionBlurScale.GetValueOnGameThread(), 0.0f, 50.0f);
FinalPostProcessSettings.MotionBlurAmount *= Value;
}
{
float Value = CVarMotionBlurMax.GetValueOnGameThread();
if(Value >= 0.0f)
{
FinalPostProcessSettings.MotionBlurMax = FMath::Min(FinalPostProcessSettings.MotionBlurMax, Value);
}
}
{
float Value = CVarSceneColorFringeMax.GetValueOnGameThread();
if (Value >= 0.0f)
{
FinalPostProcessSettings.SceneFringeIntensity = FMath::Min(FinalPostProcessSettings.SceneFringeIntensity, Value);
}
}
if (!Family->EngineShowFlags.Lighting || !Family->EngineShowFlags.GlobalIllumination)
{
FinalPostProcessSettings.IndirectLightingColor = FLinearColor(0,0,0,0);
FinalPostProcessSettings.IndirectLightingIntensity = 0.0f;
}
// Anti-Aliasing
{
const auto FeatureLevel = GetFeatureLevel();
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.PostProcessAAQuality"));
static auto* MobileHDRCvar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.MobileHDR"));
static auto* MobileMSAACvar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.MobileMSAA"));
static uint32 MSAAValue = GShaderPlatformForFeatureLevel[FeatureLevel] == SP_OPENGL_ES2_IOS ? 1 : MobileMSAACvar->GetValueOnGameThread();
int32 Quality = FMath::Clamp(CVar->GetValueOnGameThread(), 0, 6);
if( !Family->EngineShowFlags.PostProcessing || !Family->EngineShowFlags.AntiAliasing || Quality <= 0
// Disable antialiasing in GammaLDR mode to avoid jittering.
|| (FeatureLevel == ERHIFeatureLevel::ES2 && MobileHDRCvar->GetValueOnGameThread() == 0)
|| (FeatureLevel <= ERHIFeatureLevel::ES3_1 && (MSAAValue > 1)))
{
FinalPostProcessSettings.AntiAliasingMethod = AAM_None;
}
if( FinalPostProcessSettings.AntiAliasingMethod == AAM_TemporalAA)
{
if( !Family->EngineShowFlags.TemporalAA || !Family->bRealtimeUpdate || Quality < 3 )
{
FinalPostProcessSettings.AntiAliasingMethod = AAM_FXAA;
}
}
}
if (AllowDebugViewmodes())
{
ConfigureBufferVisualizationSettings();
}
#if WITH_EDITOR
FHighResScreenshotConfig& Config = GetHighResScreenshotConfig();
// Pass highres screenshot materials through post process settings
FinalPostProcessSettings.HighResScreenshotMaterial = Config.HighResScreenshotMaterial;
FinalPostProcessSettings.HighResScreenshotMaskMaterial = Config.HighResScreenshotMaskMaterial;
FinalPostProcessSettings.HighResScreenshotCaptureRegionMaterial = NULL;
// If the highres screenshot UI is open and we're not taking a highres screenshot this frame
if (Config.bDisplayCaptureRegion && !GIsHighResScreenshot)
{
// Only enable the capture region effect if the capture region is different from the view rectangle...
if ((Config.UnscaledCaptureRegion != ViewRect) && (Config.UnscaledCaptureRegion.Area() > 0) && (State != NULL))
{
// ...and if this is the viewport associated with the highres screenshot UI
auto ConfigViewport = Config.TargetViewport.Pin();
if (ConfigViewport.IsValid() && Family && Family->RenderTarget == ConfigViewport->GetViewport())
{
static const FName ParamName = "RegionRect";
FLinearColor NormalizedCaptureRegion;
// Normalize capture region into view rectangle
NormalizedCaptureRegion.R = (float)Config.UnscaledCaptureRegion.Min.X / (float)ViewRect.Width();
NormalizedCaptureRegion.G = (float)Config.UnscaledCaptureRegion.Min.Y / (float)ViewRect.Height();
NormalizedCaptureRegion.B = (float)Config.UnscaledCaptureRegion.Max.X / (float)ViewRect.Width();
NormalizedCaptureRegion.A = (float)Config.UnscaledCaptureRegion.Max.Y / (float)ViewRect.Height();
// Get a MID for drawing this frame and push the capture region into the shader parameter
FinalPostProcessSettings.HighResScreenshotCaptureRegionMaterial = State->GetReusableMID(Config.HighResScreenshotCaptureRegionMaterial);
FinalPostProcessSettings.HighResScreenshotCaptureRegionMaterial->SetVectorParameterValue(ParamName, NormalizedCaptureRegion);
}
}
}
#endif // WITH_EDITOR
// Upscaling or Super sampling
{
float LocalScreenPercentage = FinalPostProcessSettings.ScreenPercentage;
float Fraction = 1.0f;
// apply ScreenPercentage
if (LocalScreenPercentage != 100.f)
{
Fraction = FMath::Clamp(LocalScreenPercentage / 100.0f, 0.1f, 4.0f);
}
// Window full screen mode with upscaling
bool bFullscreen = false;
if (GEngine && GEngine->GameViewport && GEngine->GameViewport->GetWindow().IsValid())
{
bFullscreen = GEngine->GameViewport->GetWindow()->GetWindowMode() != EWindowMode::Windowed;
}
check(Family->RenderTarget);
if (bFullscreen)
{
// CVar mode 2 is fullscreen with upscale
if(GSystemResolution.WindowMode == EWindowMode::WindowedFullscreen)
{
// FIntPoint WindowSize = Viewport->GetSizeXY();
FIntPoint WindowSize = Family->RenderTarget->GetSizeXY();
// allow only upscaling
float FractionX = FMath::Clamp((float)GSystemResolution.ResX / WindowSize.X, 0.1f, 4.0f);
float FractionY = FMath::Clamp((float)GSystemResolution.ResY / WindowSize.Y, 0.1f, 4.0f);
// maintain a pixel aspect ratio of 1:1 for easier internal computations
Fraction *= FMath::Max(FractionX, FractionY);
}
}
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
if(CVarScreenPercentageEditor.GetValueOnAnyThread() == 0)
{
bool bNotInGame = GEngine && GEngine->GameViewport == 0;
if(bNotInGame)
{
Fraction = 1.0f;
}
}
#endif
// Upscale if needed
if (Fraction != 1.0f)
{
// compute the view rectangle with the ScreenPercentage applied
const FIntRect ScreenPercentageAffectedViewRect = ViewInitOptions.GetConstrainedViewRect().Scale(Fraction);
SetScaledViewRect(ScreenPercentageAffectedViewRect);
}
}
}
void ShaderMapAppendKeyString(EShaderPlatform Platform, FString& KeyString)
{
// Globals that should cause all shaders to recompile when changed must be appended to the key here
// Key should be kept as short as possible while being somewhat human readable for debugging
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("Compat.UseDXT5NormalMaps"));
KeyString += (CVar && CVar->GetValueOnAnyThread() != 0) ? TEXT("_DXTN") : TEXT("_BC5N");
}
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.CompileShadersForDevelopment"));
KeyString += (CVar && CVar->GetValueOnAnyThread() != 0) ? TEXT("_DEV") : TEXT("_NoDEV");
}
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.AllowStaticLighting"));
const bool bValue = CVar ? CVar->GetValueOnAnyThread() != 0 : true;
KeyString += bValue ? TEXT("_SL") : TEXT("_NoSL");
}
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.BasePassOutputsVelocity"));
if (CVar && CVar->GetValueOnGameThread() != 0)
{
KeyString += TEXT("_GV");
}
}
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("vr.InstancedStereo"));
if ((Platform == EShaderPlatform::SP_PCD3D_SM5 || Platform == EShaderPlatform::SP_PS4) && (CVar && CVar->GetValueOnGameThread() != 0))
{
KeyString += TEXT("_VRIS");
}
}
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.SelectiveBasePassOutputs"));
if (CVar && CVar->GetValueOnGameThread() != 0)
{
KeyString += TEXT("_SO");
}
}
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.GBuffer"));
if (CVar ? CVar->GetValueOnAnyThread() == 0 : false)
{
KeyString += TEXT("_NoGB");
}
}
{
static IConsoleVariable* CVar = IConsoleManager::Get().FindConsoleVariable(TEXT("r.DBuffer"));
KeyString += (CVar && CVar->GetInt() != 0) ? TEXT("_DBuf") : TEXT("_NoDBuf");
}
{
static const auto CVar = IConsoleManager::Get().FindConsoleVariable(TEXT("r.Shaders.KeepDebugInfo"));
KeyString += (CVar && CVar->GetInt() != 0) ? TEXT("_NoStrip") : TEXT("");
}
{
static const auto CVar = IConsoleManager::Get().FindConsoleVariable(TEXT("r.Shaders.Optimize"));
KeyString += (CVar && CVar->GetInt() != 0) ? TEXT("") : TEXT("_NoOpt");
}
{
static const auto CVar = IConsoleManager::Get().FindConsoleVariable(TEXT("r.Shaders.FastMath"));
KeyString += (CVar && CVar->GetInt() != 0) ? TEXT("") : TEXT("_NoFastMath");
}
{
static const auto CVar = IConsoleManager::Get().FindConsoleVariable(TEXT("r.Shaders.AvoidFlowControl"));
KeyString += (CVar && CVar->GetInt() != 0) ? TEXT("_Unroll") : TEXT("_Flow");
}
if (Platform == SP_PS4)
{
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.PS4MixedModeShaderDebugInfo"));
if (CVar && CVar->GetValueOnAnyThread() != 0)
{
KeyString += TEXT("_MMDBG");
}
}
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.PS4DumpShaderSDB"));
if (CVar && CVar->GetValueOnAnyThread() != 0)
{
KeyString += TEXT("_SDB");
}
}
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.PS4UseTTrace"));
if (CVar && CVar->GetValueOnAnyThread() > 0)
{
KeyString += FString::Printf(TEXT("TT%d"), CVar->GetValueOnAnyThread());
}
}
}
{
static const auto CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.EarlyZPass"));
if (CVar)
{
KeyString += FString::Printf(TEXT("_EARLYZ%d"), CVar->GetValueOnAnyThread());
}
}
}
/** Exposes creation of physics-engine scene outside Engine (for use with PhAT for example). */
FPhysScene::FPhysScene()
{
LineBatcher = NULL;
OwningWorld = NULL;
#if WITH_PHYSX
VehicleManager = NULL;
PhysxUserData = FPhysxUserData(this);
// Create dispatcher for tasks
if (PhysSingleThreadedMode())
{
CPUDispatcher = new FPhysXCPUDispatcherSingleThread();
}
else
{
CPUDispatcher = new FPhysXCPUDispatcher();
}
// Create sim event callback
SimEventCallback = new FPhysXSimEventCallback();
#endif //#if WITH_PHYSX
// initialize console variable - this console variable change requires it to restart scene.
static bool bInitializeConsoleVariable = true;
static float InitialAverageFrameRate = 0.016f;
UPhysicsSettings * PhysSetting = UPhysicsSettings::Get();
if (bInitializeConsoleVariable)
{
InitialAverageFrameRate = PhysSetting->InitialAverageFrameRate;
FrameTimeSmoothingFactor[PST_Sync] = PhysSetting->SyncSceneSmoothingFactor;
FrameTimeSmoothingFactor[PST_Async] = PhysSetting->AsyncSceneSmoothingFactor;
bInitializeConsoleVariable = false;
}
#if WITH_SUBSTEPPING
bSubstepping = PhysSetting->bSubstepping;
#endif
static auto CVar_AsyncSceneEnabled = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("p.EnableAsyncScene"));
bAsyncSceneEnabled = CVar_AsyncSceneEnabled->GetValueOnGameThread() == 1;
NumPhysScenes = bAsyncSceneEnabled ? PST_MAX : PST_Async;
// Create scenes of all scene types
for(uint32 SceneType = 0; SceneType < NumPhysScenes; ++SceneType)
{
// Create the physics scene
InitPhysScene(SceneType);
// Also initialize scene data
bPhysXSceneExecuting[SceneType] = false;
// Initialize to a value which would be acceptable if FrameTimeSmoothingFactor[i] = 1.0f, i.e. constant simulation substeps
AveragedFrameTime[SceneType] = InitialAverageFrameRate;
// gets from console variable, and clamp to [0, 1] - 1 should be fixed time as 30 fps
FrameTimeSmoothingFactor[SceneType] = FMath::Clamp<float>(FrameTimeSmoothingFactor[SceneType], 0.f, 1.f);
}
// Make sure we use the sync scene for apex world support of destructibles in the async scene
#if WITH_APEX
NxApexScene* ApexScene = GetApexScene(bAsyncSceneEnabled ? PST_Async : PST_Sync);
check(ApexScene);
PxScene* SyncPhysXScene = GetPhysXScene(PST_Sync);
check(SyncPhysXScene);
check(GApexModuleDestructible);
GApexModuleDestructible->setWorldSupportPhysXScene(*ApexScene, SyncPhysXScene);
#endif
}