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);
}
}
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);
});
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);
}
}