FSceneView* FJavascriptUMGViewportClient::CalcSceneView(FSceneViewFamily* ViewFamily)
{
FSceneViewInitOptions ViewInitOptions;
const FVector& ViewLocation = GetViewLocation();
const FRotator& ViewRotation = GetViewRotation();
const FIntPoint ViewportSizeXY = Viewport->GetSizeXY();
FIntRect ViewRect = FIntRect(0, 0, ViewportSizeXY.X, ViewportSizeXY.Y);
ViewInitOptions.SetViewRectangle(ViewRect);
ViewInitOptions.ViewOrigin = ViewLocation;
ViewInitOptions.ViewRotationMatrix = FInverseRotationMatrix(ViewRotation);
ViewInitOptions.ViewRotationMatrix = ViewInitOptions.ViewRotationMatrix * FMatrix(
FPlane(0, 0, 1, 0),
FPlane(1, 0, 0, 0),
FPlane(0, 1, 0, 0),
FPlane(0, 0, 0, 1));
//@TODO: Should probably be locally configurable (or just made into a FMinimalViewInfo property)
const EAspectRatioAxisConstraint AspectRatioAxisConstraint = GetDefault<ULocalPlayer>()->AspectRatioAxisConstraint;
FMinimalViewInfo::CalculateProjectionMatrixGivenView(ViewInfo, AspectRatioAxisConstraint, Viewport, /*inout*/ ViewInitOptions);
ViewInitOptions.ViewFamily = ViewFamily;
ViewInitOptions.SceneViewStateInterface = ViewState.GetReference();
ViewInitOptions.ViewElementDrawer = this;
ViewInitOptions.BackgroundColor = GetBackgroundColor();
//ViewInitOptions.EditorViewBitflag = 0, // send the bit for this view - each actor will check it's visibility bits against this
// for ortho views to steal perspective view origin
//ViewInitOptions.OverrideLODViewOrigin = FVector::ZeroVector;
//ViewInitOptions.bUseFauxOrthoViewPos = true;
//ViewInitOptions.CursorPos = CurrentMousePos;
FSceneView* View = new FSceneView(ViewInitOptions);
ViewFamily->Views.Add(View);
View->StartFinalPostprocessSettings(ViewLocation);
//OverridePostProcessSettings(*View);
View->EndFinalPostprocessSettings(ViewInitOptions);
return View;
}
void ULevelThumbnailRenderer::GetView(ULevel* Level, FSceneViewFamily* ViewFamily, int32 X, int32 Y, uint32 SizeX, uint32 SizeY) const
{
check(ViewFamily);
FIntRect ViewRect(
FMath::Max<int32>(X,0),
FMath::Max<int32>(Y,0),
FMath::Max<int32>(X+SizeX,0),
FMath::Max<int32>(Y+SizeY,0));
FBox LevelBox(0);
if (Level->LevelBoundsActor.IsValid())
{
LevelBox = Level->LevelBoundsActor.Get()->GetComponentsBoundingBox();
}
else
{
LevelBox = ALevelBounds::CalculateLevelBounds(Level);
}
if (ViewRect.Width() > 0 && ViewRect.Height() > 0)
{
FSceneViewInitOptions ViewInitOptions;
ViewInitOptions.SetViewRectangle(ViewRect);
ViewInitOptions.ViewFamily = ViewFamily;
const FVector ViewPoint = LevelBox.GetCenter();
ViewInitOptions.ViewMatrix = FMatrix(
FPlane(1, 0, 0, 0),
FPlane(0, -1, 0, 0),
FPlane(0, 0, -1, 0),
FPlane(-ViewPoint.X, ViewPoint.Y, 0, 1));
const float ZOffset = WORLD_MAX;
ViewInitOptions.ProjectionMatrix = FReversedZOrthoMatrix(
LevelBox.GetSize().X/2.f,
LevelBox.GetSize().Y/2.f,
0.5f / ZOffset,
ZOffset
);
FSceneView* NewView = new FSceneView(ViewInitOptions);
ViewFamily->Views.Add(NewView);
}
}
FVector2D SGameLayerManager::GetAspectRatioInset(ULocalPlayer* LocalPlayer) const
{
QUICK_SCOPE_CYCLE_COUNTER(STAT_SGameLayerManager_GetAspectRatioInset);
FVector2D Offset(0.f, 0.f);
if (LocalPlayer)
{
FSceneViewInitOptions ViewInitOptions;
if (LocalPlayer->CalcSceneViewInitOptions(ViewInitOptions, LocalPlayer->ViewportClient->Viewport))
{
FIntRect UnscaledViewRect = ViewInitOptions.GetConstrainedViewRect();
Offset.X = -UnscaledViewRect.Min.X;
Offset.Y = -UnscaledViewRect.Min.Y;
}
}
return Offset;
}
void FRendererModule::GPUBenchmark(FSynthBenchmarkResults& InOut, float WorkScale)
{
check(IsInGameThread());
FSceneViewInitOptions ViewInitOptions;
FIntRect ViewRect(0, 0, 1, 1);
FBox LevelBox(FVector(-WORLD_MAX), FVector(+WORLD_MAX));
ViewInitOptions.SetViewRectangle(ViewRect);
// Initialize Projection Matrix and ViewMatrix since FSceneView initialization is doing some math on them.
// Otherwise it trips NaN checks.
const FVector ViewPoint = LevelBox.GetCenter();
ViewInitOptions.ViewOrigin = FVector(ViewPoint.X, ViewPoint.Y, 0.0f);
ViewInitOptions.ViewRotationMatrix = FMatrix(
FPlane(1, 0, 0, 0),
FPlane(0, -1, 0, 0),
FPlane(0, 0, -1, 0),
FPlane(0, 0, 0, 1));
const float ZOffset = WORLD_MAX;
ViewInitOptions.ProjectionMatrix = FReversedZOrthoMatrix(
LevelBox.GetSize().X / 2.f,
LevelBox.GetSize().Y / 2.f,
0.5f / ZOffset,
ZOffset
);
FSceneView DummyView(ViewInitOptions);
ENQUEUE_UNIQUE_RENDER_COMMAND_THREEPARAMETER(
RendererGPUBenchmarkCommand,
FSceneView, DummyView, DummyView,
float, WorkScale, WorkScale,
FSynthBenchmarkResults&, InOut, InOut,
{
RendererGPUBenchmark(RHICmdList, InOut, DummyView, WorkScale);
});
FSceneRenderer* FScene::CreateSceneRenderer( USceneCaptureComponent* SceneCaptureComponent, UTextureRenderTarget* TextureTarget, const FMatrix& ViewMatrix, const FVector& ViewLocation, float FOV, float MaxViewDistance, bool bCaptureSceneColour, FPostProcessSettings* PostProcessSettings, float PostProcessBlendWeight )
{
FIntPoint CaptureSize(TextureTarget->GetSurfaceWidth(), TextureTarget->GetSurfaceHeight());
FTextureRenderTargetResource* Resource = TextureTarget->GameThread_GetRenderTargetResource();
FSceneViewFamilyContext ViewFamily(FSceneViewFamily::ConstructionValues(
Resource,
this,
FEngineShowFlags(ESFIM_Game))
.SetResolveScene(!bCaptureSceneColour));
// Disable features that are not desired when capturing the scene
ViewFamily.EngineShowFlags.MotionBlur = 0; // motion blur doesn't work correctly with scene captures.
ViewFamily.EngineShowFlags.SeparateTranslucency = 0;
ViewFamily.EngineShowFlags.HMDDistortion = 0;
FSceneViewInitOptions ViewInitOptions;
ViewInitOptions.SetViewRectangle(FIntRect(0, 0, CaptureSize.X, CaptureSize.Y));
ViewInitOptions.ViewFamily = &ViewFamily;
ViewInitOptions.ViewMatrix = ViewMatrix;
ViewInitOptions.BackgroundColor = FLinearColor::Black;
ViewInitOptions.OverrideFarClippingPlaneDistance = MaxViewDistance;
if (bCaptureSceneColour)
{
ViewFamily.EngineShowFlags.PostProcessing = 0;
ViewInitOptions.OverlayColor = FLinearColor::Black;
}
// Build projection matrix
{
float XAxisMultiplier;
float YAxisMultiplier;
if (CaptureSize.X > CaptureSize.Y)
{
// if the viewport is wider than it is tall
XAxisMultiplier = 1.0f;
YAxisMultiplier = CaptureSize.X / (float)CaptureSize.Y;
}
else
{
// if the viewport is taller than it is wide
XAxisMultiplier = CaptureSize.Y / (float)CaptureSize.X;
YAxisMultiplier = 1.0f;
}
ViewInitOptions.ProjectionMatrix = FReversedZPerspectiveMatrix (
FOV,
FOV,
XAxisMultiplier,
YAxisMultiplier,
GNearClippingPlane,
GNearClippingPlane
);
}
FSceneView* View = new FSceneView(ViewInitOptions);
View->bIsSceneCapture = true;
check(SceneCaptureComponent);
for (auto It = SceneCaptureComponent->HiddenComponents.CreateConstIterator(); It; ++It)
{
// If the primitive component was destroyed, the weak pointer will return NULL.
UPrimitiveComponent* PrimitiveComponent = It->Get();
if (PrimitiveComponent)
{
View->HiddenPrimitives.Add(PrimitiveComponent->ComponentId);
}
}
ViewFamily.Views.Add(View);
View->StartFinalPostprocessSettings(ViewLocation);
if (!bCaptureSceneColour)
{
View->OverridePostProcessSettings(*PostProcessSettings, PostProcessBlendWeight);
}
View->EndFinalPostprocessSettings();
return FSceneRenderer::CreateSceneRenderer(&ViewFamily, NULL);
}
void UWorldThumbnailRenderer::GetView(UWorld* World, FSceneViewFamily* ViewFamily, int32 X, int32 Y, uint32 SizeX, uint32 SizeY) const
{
check(ViewFamily);
check(World);
check(World->PersistentLevel);
FIntRect ViewRect(
FMath::Max<int32>(X, 0),
FMath::Max<int32>(Y, 0),
FMath::Max<int32>(X + SizeX, 0),
FMath::Max<int32>(Y + SizeY, 0));
if (ViewRect.Width() > 0 && ViewRect.Height() > 0)
{
FBox WorldBox(0);
TArray<ULevel*> LevelsToRender = World->GetLevels();
for ( auto* Level : LevelsToRender )
{
if (Level && Level->bIsVisible)
{
ALevelBounds* LevelBounds = Level->LevelBoundsActor.Get();
if (!LevelBounds)
{
// Ensure a Level Bounds Actor exists for future renders
FActorSpawnParameters SpawnParameters;
SpawnParameters.OverrideLevel = Level;
LevelBounds = World->SpawnActor<ALevelBounds>(SpawnParameters);
LevelBounds->UpdateLevelBoundsImmediately();
Level->LevelBoundsActor = LevelBounds;
}
if (!LevelBounds->IsUsingDefaultBounds())
{
WorldBox += LevelBounds->GetComponentsBoundingBox();
}
}
}
UWorldThumbnailInfo* ThumbnailInfo = Cast<UWorldThumbnailInfo>(World->ThumbnailInfo);
if (!ThumbnailInfo)
{
ThumbnailInfo = UWorldThumbnailInfo::StaticClass()->GetDefaultObject<UWorldThumbnailInfo>();
}
const FVector Origin = WorldBox.GetCenter();
FMatrix ViewMatrix = FTranslationMatrix(-Origin);
FMatrix ProjectionMatrix;
float FOVScreenSize = 0; // Screen size taking FOV into account
if (ThumbnailInfo->CameraMode == ECameraProjectionMode::Perspective)
{
const float FOVDegrees = 30.f;
const float HalfFOVRadians = FMath::DegreesToRadians<float>(FOVDegrees) * 0.5f;
const float WorldRadius = WorldBox.GetSize().Size() / 2.f;
float TargetDistance = WorldRadius / FMath::Tan(HalfFOVRadians);
if (ensure(ThumbnailInfo))
{
if (TargetDistance + ThumbnailInfo->OrbitZoom < 0)
{
ThumbnailInfo->OrbitZoom = -TargetDistance;
}
}
float OrbitPitch = GlobalOrbitPitchOffset + ThumbnailInfo->OrbitPitch;
float OrbitYaw = GlobalOrbitYawOffset + ThumbnailInfo->OrbitYaw;
float OrbitZoom = TargetDistance + ThumbnailInfo->OrbitZoom;
// Ensure a minimum camera distance to prevent problems with really small objects
const float MinCameraDistance = 48;
OrbitZoom = FMath::Max<float>(MinCameraDistance, OrbitZoom);
const FRotator RotationOffsetToViewCenter(0.f, 90.f, 0.f);
ViewMatrix = ViewMatrix *
FRotationMatrix(FRotator(0, OrbitYaw, 0)) *
FRotationMatrix(FRotator(0, 0, OrbitPitch)) *
FTranslationMatrix(FVector(0, OrbitZoom, 0)) *
FInverseRotationMatrix(RotationOffsetToViewCenter);
ViewMatrix = ViewMatrix * FMatrix(
FPlane(0, 0, 1, 0),
FPlane(1, 0, 0, 0),
FPlane(0, 1, 0, 0),
FPlane(0, 0, 0, 1));
const float NearPlane = 1.0f;
ProjectionMatrix = FReversedZPerspectiveMatrix(
HalfFOVRadians,
1.0f,
1.0f,
NearPlane
);
FOVScreenSize = SizeX / FMath::Tan(FOVDegrees);
}
else if (ThumbnailInfo->CameraMode == ECameraProjectionMode::Orthographic)
{
FVector2D WorldSizeMin2D;
FVector2D WorldSizeMax2D;
switch (ThumbnailInfo->OrthoDirection)
{
case EOrthoThumbnailDirection::Top:
ViewMatrix = ViewMatrix * FMatrix(
FPlane(1, 0, 0, 0),
FPlane(0, -1, 0, 0),
FPlane(0, 0, -1, 0),
FPlane(0, 0, Origin.Z, 1));
WorldSizeMin2D = FVector2D(WorldBox.Min.X,WorldBox.Min.Y);
WorldSizeMax2D = FVector2D(WorldBox.Max.X,WorldBox.Max.Y);
break;
case EOrthoThumbnailDirection::Bottom:
ViewMatrix = ViewMatrix * FMatrix(
FPlane(1, 0, 0, 0),
FPlane(0, -1, 0, 0),
FPlane(0, 0, 1, 0),
FPlane(0, 0, Origin.Z, 1));
WorldSizeMin2D = FVector2D(WorldBox.Min.X, WorldBox.Min.Y);
WorldSizeMax2D = FVector2D(WorldBox.Max.X, WorldBox.Max.Y);
break;
case EOrthoThumbnailDirection::Front:
ViewMatrix = ViewMatrix * FMatrix(
FPlane(1, 0, 0, 0),
FPlane(0, 0, -1, 0),
FPlane(0, 1, 0, 0),
FPlane(0, 0, Origin.Y, 1));
WorldSizeMin2D = FVector2D(WorldBox.Min.X, WorldBox.Min.Z);
WorldSizeMax2D = FVector2D(WorldBox.Max.X, WorldBox.Max.Z);
break;
case EOrthoThumbnailDirection::Back:
ViewMatrix = ViewMatrix * FMatrix(
FPlane(-1, 0, 0, 0),
FPlane(0, 0, 1, 0),
FPlane(0, 1, 0, 0),
FPlane(0, 0, Origin.Y, 1));
WorldSizeMin2D = FVector2D(WorldBox.Min.X, WorldBox.Min.Z);
WorldSizeMax2D = FVector2D(WorldBox.Max.X, WorldBox.Max.Z);
break;
case EOrthoThumbnailDirection::Left:
ViewMatrix = ViewMatrix * FMatrix(
FPlane(0, 0, -1, 0),
FPlane(-1, 0, 0, 0),
FPlane(0, 1, 0, 0),
FPlane(0, 0, Origin.X, 1));
WorldSizeMin2D = FVector2D(WorldBox.Min.Y, WorldBox.Min.Z);
WorldSizeMax2D = FVector2D(WorldBox.Max.Y, WorldBox.Max.Z);
break;
case EOrthoThumbnailDirection::Right:
ViewMatrix = ViewMatrix * FMatrix(
FPlane(0, 0, 1, 0),
FPlane(1, 0, 0, 0),
FPlane(0, 1, 0, 0),
FPlane(0, 0, Origin.X, 1));
WorldSizeMin2D = FVector2D(WorldBox.Min.Y, WorldBox.Min.Z);
WorldSizeMax2D = FVector2D(WorldBox.Max.Y, WorldBox.Max.Z);
break;
default:
// Unknown OrthoDirection
ensureMsgf(false, TEXT("Unknown thumbnail OrthoDirection"));
break;
}
FVector2D WorldSize2D = (WorldSizeMax2D - WorldSizeMin2D);
WorldSize2D.X = FMath::Abs(WorldSize2D.X);
WorldSize2D.Y = FMath::Abs(WorldSize2D.Y);
const bool bUseXAxis = (WorldSize2D.X / WorldSize2D.Y) > 1.f;
const float WorldAxisSize = bUseXAxis ? WorldSize2D.X : WorldSize2D.Y;
const uint32 ViewportAxisSize = bUseXAxis ? SizeX : SizeY;
const float OrthoZoom = WorldAxisSize / ViewportAxisSize / 2.f;
const float OrthoWidth = FMath::Max(1.f, SizeX * OrthoZoom);
const float OrthoHeight = FMath::Max(1.f, SizeY * OrthoZoom);
const float ZOffset = HALF_WORLD_MAX;
ProjectionMatrix = FReversedZOrthoMatrix(
OrthoWidth,
OrthoHeight,
0.5f / ZOffset,
ZOffset
);
FOVScreenSize = SizeX;
}
else
{
// Unknown CameraMode
ensureMsgf(false, TEXT("Unknown thumbnail CameraMode"));
}
FSceneViewInitOptions ViewInitOptions;
ViewInitOptions.ViewFamily = ViewFamily;
ViewInitOptions.SetViewRectangle(ViewRect);
ViewInitOptions.BackgroundColor = FLinearColor::Black;
ViewInitOptions.ViewMatrix = ViewMatrix;
ViewInitOptions.ProjectionMatrix = ProjectionMatrix;
FSceneView* NewView = new FSceneView(ViewInitOptions);
ViewFamily->Views.Add(NewView);
// Tell the texture streaming system about this thumbnail view, so the textures will stream in as needed
// NOTE: Sizes may not actually be in screen space depending on how the thumbnail ends up stretched by the UI. Not a big deal though.
// NOTE: Textures still take a little time to stream if the view has not been re-rendered recently, so they may briefly appear blurry while mips are prepared
// NOTE: Content Browser only renders thumbnails for loaded assets, and only when the mouse is over the panel. They'll be frozen in their last state while the mouse cursor is not over the panel. This is for performance reasons
IStreamingManager::Get().AddViewInformation(Origin, SizeX, FOVScreenSize);
}
}
static FSceneView& CreateSceneView( FSceneViewFamilyContext& ViewFamilyContext, FSlateBackBuffer& BackBuffer, const FMatrix& ViewProjectionMatrix )
{
FIntRect ViewRect(FIntPoint(0, 0), BackBuffer.GetSizeXY());
// make a temporary view
FSceneViewInitOptions ViewInitOptions;
ViewInitOptions.ViewFamily = &ViewFamilyContext;
ViewInitOptions.SetViewRectangle(ViewRect);
ViewInitOptions.ViewOrigin = FVector::ZeroVector;
ViewInitOptions.ViewRotationMatrix = FMatrix::Identity;
ViewInitOptions.ProjectionMatrix = ViewProjectionMatrix;
ViewInitOptions.BackgroundColor = FLinearColor::Black;
ViewInitOptions.OverlayColor = FLinearColor::White;
FSceneView* View = new FSceneView( ViewInitOptions );
ViewFamilyContext.Views.Add( View );
/** The view transform, starting from world-space points translated by -ViewOrigin. */
FMatrix EffectiveTranslatedViewMatrix = FTranslationMatrix(-View->ViewMatrices.PreViewTranslation) * View->ViewMatrices.ViewMatrix;
// Create the view's uniform buffer.
FViewUniformShaderParameters ViewUniformShaderParameters;
ViewUniformShaderParameters.TranslatedWorldToClip = View->ViewMatrices.TranslatedViewProjectionMatrix;
ViewUniformShaderParameters.WorldToClip = ViewProjectionMatrix;
ViewUniformShaderParameters.TranslatedWorldToView = EffectiveTranslatedViewMatrix;
ViewUniformShaderParameters.ViewToTranslatedWorld = View->InvViewMatrix * FTranslationMatrix(View->ViewMatrices.PreViewTranslation);
ViewUniformShaderParameters.ViewToClip = View->ViewMatrices.ProjMatrix;
ViewUniformShaderParameters.ClipToTranslatedWorld = View->ViewMatrices.InvTranslatedViewProjectionMatrix;
ViewUniformShaderParameters.ViewForward = EffectiveTranslatedViewMatrix.GetColumn(2);
ViewUniformShaderParameters.ViewUp = EffectiveTranslatedViewMatrix.GetColumn(1);
ViewUniformShaderParameters.ViewRight = EffectiveTranslatedViewMatrix.GetColumn(0);
ViewUniformShaderParameters.InvDeviceZToWorldZTransform = View->InvDeviceZToWorldZTransform;
ViewUniformShaderParameters.ScreenPositionScaleBias = FVector4(0,0,0,0);
ViewUniformShaderParameters.ViewRectMin = FVector4(ViewRect.Min.X, ViewRect.Min.Y, 0.0f, 0.0f);
ViewUniformShaderParameters.ViewSizeAndSceneTexelSize = FVector4(ViewRect.Width(), ViewRect.Height(), 1.0f/ViewRect.Width(), 1.0f/ViewRect.Height() );
ViewUniformShaderParameters.ViewOrigin = View->ViewMatrices.ViewOrigin;
ViewUniformShaderParameters.TranslatedViewOrigin = View->ViewMatrices.ViewOrigin + View->ViewMatrices.PreViewTranslation;
ViewUniformShaderParameters.DiffuseOverrideParameter = View->DiffuseOverrideParameter;
ViewUniformShaderParameters.SpecularOverrideParameter = View->SpecularOverrideParameter;
ViewUniformShaderParameters.NormalOverrideParameter = View->NormalOverrideParameter;
ViewUniformShaderParameters.RoughnessOverrideParameter = View->RoughnessOverrideParameter;
ViewUniformShaderParameters.PrevFrameGameTime = View->Family->CurrentWorldTime - View->Family->DeltaWorldTime;
ViewUniformShaderParameters.PrevFrameRealTime = View->Family->CurrentRealTime - View->Family->DeltaWorldTime;
ViewUniformShaderParameters.PreViewTranslation = View->ViewMatrices.PreViewTranslation;
ViewUniformShaderParameters.CullingSign = View->bReverseCulling ? -1.0f : 1.0f;
ViewUniformShaderParameters.NearPlane = GNearClippingPlane;
ViewUniformShaderParameters.GameTime = View->Family->CurrentWorldTime;
ViewUniformShaderParameters.RealTime = View->Family->CurrentRealTime;
ViewUniformShaderParameters.Random = FMath::Rand();
ViewUniformShaderParameters.FrameNumber = View->Family->FrameNumber;
ViewUniformShaderParameters.DirectionalLightShadowTexture = GWhiteTexture->TextureRHI;
ViewUniformShaderParameters.DirectionalLightShadowSampler = TStaticSamplerState<SF_Point, AM_Clamp, AM_Clamp, AM_Clamp>::GetRHI();
ViewUniformShaderParameters.ScreenToWorld = FMatrix(
FPlane(1, 0, 0, 0),
FPlane(0, 1, 0, 0),
FPlane(0, 0, View->ProjectionMatrixUnadjustedForRHI.M[2][2], 1),
FPlane(0, 0, View->ProjectionMatrixUnadjustedForRHI.M[3][2], 0))
* View->InvViewProjectionMatrix;
ViewUniformShaderParameters.ScreenToTranslatedWorld = FMatrix(
FPlane(1, 0, 0, 0),
FPlane(0, 1, 0, 0),
FPlane(0, 0, View->ProjectionMatrixUnadjustedForRHI.M[2][2], 1),
FPlane(0, 0, View->ProjectionMatrixUnadjustedForRHI.M[3][2], 0))
* View->ViewMatrices.InvTranslatedViewProjectionMatrix;
View->UniformBuffer = TUniformBufferRef<FViewUniformShaderParameters>::CreateUniformBufferImmediate(ViewUniformShaderParameters, UniformBuffer_SingleFrame);
return *View;
}
void FThumbnailPreviewScene::GetView(FSceneViewFamily* ViewFamily, int32 X, int32 Y, uint32 SizeX, uint32 SizeY) const
{
check(ViewFamily);
FIntRect ViewRect(
FMath::Max<int32>(X,0),
FMath::Max<int32>(Y,0),
FMath::Max<int32>(X+SizeX,0),
FMath::Max<int32>(Y+SizeY,0));
if (ViewRect.Width() > 0 && ViewRect.Height() > 0)
{
const float FOVDegrees = 30.f;
const float HalfFOVRadians = FMath::DegreesToRadians<float>(FOVDegrees) * 0.5f;
static_assert((int32)ERHIZBuffer::IsInverted != 0, "Check NearPlane and Projection Matrix");
const float NearPlane = 1.0f;
FMatrix ProjectionMatrix = FReversedZPerspectiveMatrix(
HalfFOVRadians,
1.0f,
1.0f,
NearPlane
);
FVector Origin(0);
float OrbitPitch = 0;
float OrbitYaw = 0;
float OrbitZoom = 0;
GetViewMatrixParameters(FOVDegrees, Origin, OrbitPitch, OrbitYaw, OrbitZoom);
// Ensure a minimum camera distance to prevent problems with really small objects
const float MinCameraDistance = 48;
OrbitZoom = FMath::Max<float>(MinCameraDistance, OrbitZoom);
const FRotator RotationOffsetToViewCenter(0.f, 90.f, 0.f);
FMatrix ViewRotationMatrix = FRotationMatrix( FRotator(0, OrbitYaw, 0) ) *
FRotationMatrix( FRotator(0, 0, OrbitPitch) ) *
FTranslationMatrix( FVector(0, OrbitZoom, 0) ) *
FInverseRotationMatrix( RotationOffsetToViewCenter );
ViewRotationMatrix = ViewRotationMatrix * FMatrix(
FPlane(0, 0, 1, 0),
FPlane(1, 0, 0, 0),
FPlane(0, 1, 0, 0),
FPlane(0, 0, 0, 1));
Origin -= ViewRotationMatrix.InverseTransformPosition( FVector::ZeroVector );
ViewRotationMatrix = ViewRotationMatrix.RemoveTranslation();
FSceneViewInitOptions ViewInitOptions;
ViewInitOptions.ViewFamily = ViewFamily;
ViewInitOptions.SetViewRectangle(ViewRect);
ViewInitOptions.ViewOrigin = -Origin;
ViewInitOptions.ViewRotationMatrix = ViewRotationMatrix;
ViewInitOptions.ProjectionMatrix = ProjectionMatrix;
ViewInitOptions.BackgroundColor = FLinearColor::Black;
FSceneView* NewView = new FSceneView(ViewInitOptions);
ViewFamily->Views.Add(NewView);
NewView->StartFinalPostprocessSettings( ViewInitOptions.ViewOrigin );
NewView->EndFinalPostprocessSettings(ViewInitOptions);
FFinalPostProcessSettings::FCubemapEntry& CubemapEntry = *new(NewView->FinalPostProcessSettings.ContributingCubemaps) FFinalPostProcessSettings::FCubemapEntry;
CubemapEntry.AmbientCubemap = GUnrealEd->GetThumbnailManager()->AmbientCubemap;
const float AmbientCubemapIntensity = 1.69;
CubemapEntry.AmbientCubemapTintMulScaleValue = FLinearColor::White * AmbientCubemapIntensity;
// Tell the texture streaming system about this thumbnail view, so the textures will stream in as needed
// NOTE: Sizes may not actually be in screen space depending on how the thumbnail ends up stretched by the UI. Not a big deal though.
// NOTE: Textures still take a little time to stream if the view has not been re-rendered recently, so they may briefly appear blurry while mips are prepared
// NOTE: Content Browser only renders thumbnails for loaded assets, and only when the mouse is over the panel. They'll be frozen in their last state while the mouse cursor is not over the panel. This is for performance reasons
IStreamingManager::Get().AddViewInformation( Origin, SizeX, SizeX / FMath::Tan( FOVDegrees ) );
}
}
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 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 RenderLandscapeMaterialForLightmass(const FLandscapeStaticLightingMesh* LandscapeMesh, FMaterialRenderProxy* MaterialProxy, const FRenderTarget* RenderTarget)
{
const ULandscapeComponent* LandscapeComponent = CastChecked<ULandscapeComponent>(LandscapeMesh->Component);
const int32 SubsectionSizeQuads = LandscapeComponent->SubsectionSizeQuads;
const int32 NumSubsections = LandscapeComponent->NumSubsections;
const int32 ComponentSizeQuads = LandscapeComponent->ComponentSizeQuads;
int32 PatchExpandCountX = 0;
int32 PatchExpandCountY = 0;
int32 DesiredSize = 1;
const float LightMapOffset = 0.0f;
const float LightMapRes = LandscapeComponent->StaticLightingResolution > 0.f ? LandscapeComponent->StaticLightingResolution : LandscapeComponent->GetLandscapeProxy()->StaticLightingResolution;
const int32 LightingLOD = LandscapeComponent->GetLandscapeProxy()->StaticLightingLOD;
const float LightMapRatio = ::GetTerrainExpandPatchCount(LightMapRes, PatchExpandCountX, PatchExpandCountY, ComponentSizeQuads, (NumSubsections * (SubsectionSizeQuads + 1)), DesiredSize, LightingLOD);
const FVector2D PatchExpandOffset = FVector2D((float)PatchExpandCountX / (ComponentSizeQuads + 2 * PatchExpandCountX), (float)PatchExpandCountY / (ComponentSizeQuads + 2 * PatchExpandCountY)) * FVector2D(RenderTarget->GetSizeXY());
const FVector2D PatchExpandScale = FVector2D((float)ComponentSizeQuads / (ComponentSizeQuads + 2 * PatchExpandCountX), (float)ComponentSizeQuads / (ComponentSizeQuads + 2 * PatchExpandCountY));
TArray<FLightmassLandscapeVertex> Vertices;
TArray<uint16> Indices;
Vertices.Reserve(FMath::Square(NumSubsections) * 4);
Indices.Reserve(FMath::Square(NumSubsections) * 6);
const float fraction = 1.0f / NumSubsections;
const FVector2D PositionScale = FVector2D(RenderTarget->GetSizeXY()) * fraction * PatchExpandScale;
const float LayerScale = SubsectionSizeQuads;
const float WeightmapSubsection = LandscapeComponent->WeightmapSubsectionOffset;
const FVector2D WeightmapBias = FVector2D(LandscapeComponent->WeightmapScaleBias.Z, LandscapeComponent->WeightmapScaleBias.W);
const FVector2D WeightmapScale = FVector2D(LandscapeComponent->WeightmapScaleBias.X, LandscapeComponent->WeightmapScaleBias.Y) * SubsectionSizeQuads;
const int32 SubsectionX_Start = PatchExpandCountX > 0 ? -1 : 0;
const int32 SubsectionX_End = NumSubsections + (PatchExpandCountX > 0 ? 1 : 0);
const int32 SubsectionY_Start = PatchExpandCountY > 0 ? -1 : 0;
const int32 SubsectionY_End = NumSubsections + (PatchExpandCountY > 0 ? 1 : 0);
for (int32 SubsectionY = SubsectionY_Start; SubsectionY < SubsectionY_End; ++SubsectionY)
{
for (int32 SubsectionX = SubsectionX_Start; SubsectionX < SubsectionX_End; ++SubsectionX)
{
const FIntPoint UVSubsection = FIntPoint((SubsectionX >= 0 ? SubsectionX : 0),
(SubsectionY >= 0 ? SubsectionY : 0));
const FVector2D UVScale = FVector2D((SubsectionX >= 0 && SubsectionX < NumSubsections ? 1 : 0),
(SubsectionY >= 0 && SubsectionY < NumSubsections ? 1 : 0));
const FVector2D BasePosition = PatchExpandOffset + FVector2D(SubsectionX, SubsectionY) * PositionScale;
const FVector2D BaseLayerCoords = FVector2D(UVSubsection) * LayerScale;
const FVector2D BaseWeightmapCoords = WeightmapBias + FVector2D(UVSubsection) * WeightmapSubsection;
int32 Index = Vertices.Add(FLightmassLandscapeVertex(FVector(BasePosition /*FVector2D(0, 0) * PositionScale*/, 0), FVector(BaseLayerCoords /*FVector2D(0, 0) * UVScale * LayerScale*/, 0), BaseWeightmapCoords /*FVector2D(0, 0) * UVScale * WeightmapScale*/));
verifySlow( Vertices.Add(FLightmassLandscapeVertex(FVector(BasePosition + FVector2D(1, 0) * PositionScale, 0), FVector(BaseLayerCoords + FVector2D(1, 0) * UVScale * LayerScale, 0), BaseWeightmapCoords + FVector2D(1, 0) * UVScale * WeightmapScale )) == Index + 1);
verifySlow( Vertices.Add(FLightmassLandscapeVertex(FVector(BasePosition + FVector2D(0, 1) * PositionScale, 0), FVector(BaseLayerCoords + FVector2D(0, 1) * UVScale * LayerScale, 0), BaseWeightmapCoords + FVector2D(0, 1) * UVScale * WeightmapScale )) == Index + 2);
verifySlow( Vertices.Add(FLightmassLandscapeVertex(FVector(BasePosition + FVector2D(1, 1) * PositionScale, 0), FVector(BaseLayerCoords + FVector2D(1, 1) * UVScale * LayerScale, 0), BaseWeightmapCoords + FVector2D(1, 1) * UVScale * WeightmapScale )) == Index + 3);
checkSlow(Index + 3 <= MAX_uint16);
Indices.Add(Index);
Indices.Add(Index + 3);
Indices.Add(Index + 1);
Indices.Add(Index);
Indices.Add(Index + 2);
Indices.Add(Index + 3);
}
}
FMeshBatch MeshElement;
MeshElement.DynamicVertexStride = sizeof(FLightmassLandscapeVertex);
MeshElement.UseDynamicData = true;
MeshElement.bDisableBackfaceCulling = true;
MeshElement.CastShadow = false;
MeshElement.bWireframe = false;
MeshElement.Type = PT_TriangleList;
MeshElement.DepthPriorityGroup = SDPG_Foreground;
MeshElement.bUseAsOccluder = false;
MeshElement.bSelectable = false;
MeshElement.DynamicVertexData = Vertices.GetData();
MeshElement.VertexFactory = &LightmassLandscapeVertexFactory;
MeshElement.MaterialRenderProxy = MaterialProxy;
FMeshBatchElement& BatchElement = MeshElement.Elements[0];
BatchElement.PrimitiveUniformBufferResource = &LightmassLandscapeUniformBuffer;
BatchElement.DynamicIndexData = Indices.GetData();
BatchElement.FirstIndex = 0;
BatchElement.NumPrimitives = Indices.Num() / 3;
BatchElement.MinVertexIndex = 0;
BatchElement.MaxVertexIndex = Vertices.Num() - 1;
BatchElement.DynamicIndexStride = sizeof(uint16);
FSceneViewFamily ViewFamily(FSceneViewFamily::ConstructionValues(
RenderTarget,
NULL,
FEngineShowFlags(ESFIM_Game))
.SetWorldTimes(0, 0, 0)
.SetGammaCorrection(RenderTarget->GetDisplayGamma()));
const FIntRect ViewRect(FIntPoint(0, 0), RenderTarget->GetSizeXY());
// make a temporary view
FSceneViewInitOptions ViewInitOptions;
ViewInitOptions.ViewFamily = &ViewFamily;
ViewInitOptions.SetViewRectangle(ViewRect);
ViewInitOptions.ViewOrigin = FVector::ZeroVector;
ViewInitOptions.ViewRotationMatrix = FMatrix::Identity;
ViewInitOptions.ProjectionMatrix = FCanvas::CalcBaseTransform2D(RenderTarget->GetSizeXY().X, RenderTarget->GetSizeXY().Y);
ViewInitOptions.BackgroundColor = FLinearColor::Black;
ViewInitOptions.OverlayColor = FLinearColor::White;
FSceneView View(ViewInitOptions);
ENQUEUE_UNIQUE_RENDER_COMMAND_ONEPARAMETER(
CanvasFlushSetupCommand,
const FRenderTarget*, RenderTarget, RenderTarget,
{
//SCOPED_DRAW_EVENT(RHICmdList, CanvasFlush);
// Set the RHI render target.
::SetRenderTarget(RHICmdList, RenderTarget->GetRenderTargetTexture(), FTextureRHIRef());
// disable depth test & writes
RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false,CF_Always>::GetRHI());
const FIntRect RTViewRect = FIntRect(0, 0, RenderTarget->GetRenderTargetTexture()->GetSizeX(), RenderTarget->GetRenderTargetTexture()->GetSizeY());
// set viewport to RT size
RHICmdList.SetViewport(RTViewRect.Min.X, RTViewRect.Min.Y, 0.0f, RTViewRect.Max.X, RTViewRect.Max.Y, 1.0f);
});