void FOculusRiftHMD::UpdateViewport(bool bUseSeparateRenderTarget, const FViewport& InViewport, SViewport* ViewportWidget)
{
check(IsInGameThread());
if (GIsEditor && ViewportWidget)
{
// In editor we are going to check if the viewport widget supports stereo rendering or not.
if (!ViewportWidget->IsStereoRenderingAllowed())
{
return;
}
}
FRHIViewport* const ViewportRHI = InViewport.GetViewportRHI().GetReference();
TSharedPtr<SWindow> Window;
if (ViewportWidget && !IsFullscreenAllowed())
{
FWidgetPath WidgetPath;
TSharedRef<SWidget> Widget = ViewportWidget->AsShared();
Window = FSlateApplication::Get().FindWidgetWindow(Widget, WidgetPath);
}
if (!Settings->IsStereoEnabled())
{
if ((!bUseSeparateRenderTarget || GIsEditor) && ViewportRHI)
{
ViewportRHI->SetCustomPresent(nullptr);
}
// Restore AutoResizeViewport mode for the window
if (ViewportWidget && !IsFullscreenAllowed() && Settings->MirrorWindowSize.X != 0 && Settings->MirrorWindowSize.Y != 0)
{
FWidgetPath WidgetPath;
TSharedRef<SWidget> Widget = ViewportWidget->AsShared();
TSharedPtr<SWindow> Window = FSlateApplication::Get().FindWidgetWindow(Widget, WidgetPath);
if (Window.IsValid())
{
Window->SetViewportSizeDrivenByWindow(true);
}
}
return;
}
FGameFrame* CurrentFrame = GetFrame();
if (!bUseSeparateRenderTarget || !CurrentFrame)
return;
check(CurrentFrame);
CurrentFrame->ViewportSize = InViewport.GetSizeXY();
CurrentFrame->WindowSize = Window->GetSizeInScreen();
check(pCustomPresent);
pCustomPresent->UpdateViewport(InViewport, ViewportRHI, CurrentFrame);
}
float AEyeXPlayerController::GetTanOfFOVAngleScaled() const
{
FViewport* Viewport = FEyeXUtils::GetViewport();
const FVector2D ViewportSize = Viewport->GetSizeXY();
float ViewPortHeightInMm;
float ScaleFactor;
ViewPortHeightInMm = ViewportSize.Y / GetApproximatePixelsPerMillimeter();
ScaleFactor = 2.0f * SweepSphereRadius / ViewPortHeightInMm;
const float FOVRadians = FMath::DegreesToRadians(PlayerCameraManager->GetFOVAngle());
const float TanFOV = FMath::Tan(0.5f * FOVRadians);
return TanFOV * ScaleFactor;
}
void FSocketEditingHelper::DrawSocketNames(FSpriteGeometryEditMode* GeometryEditMode, UPrimitiveComponent* PreviewComponent, FViewport& Viewport, FSceneView& View, FCanvas& Canvas)
{
if (PreviewComponent != nullptr)
{
const int32 HalfX = Viewport.GetSizeXY().X / 2;
const int32 HalfY = Viewport.GetSizeXY().Y / 2;
const FColor UnselectedSocketNameColor(255, 196, 196);
const FColor SelectedSocketNameColor(FColor::White);
TArray<FComponentSocketDescription> SocketList;
PreviewComponent->QuerySupportedSockets(/*out*/ SocketList);
for (const FComponentSocketDescription& Socket : SocketList)
{
const FVector SocketWorldPos = PreviewComponent->GetSocketLocation(Socket.Name);
const FPlane Proj = View.Project(SocketWorldPos);
if (Proj.W > 0.f)
{
const int32 XPos = HalfX + (HalfX * Proj.X);
const int32 YPos = HalfY + (HalfY * (-Proj.Y));
const bool bIsSelected = (GeometryEditMode != nullptr) && GeometryEditMode->IsSocketSelected(Socket.Name);
const FColor& SocketColor = bIsSelected ? SelectedSocketNameColor : UnselectedSocketNameColor;
FCanvasTextItem Msg(FVector2D(XPos, YPos), FText::FromString(Socket.Name.ToString()), GEngine->GetMediumFont(), SocketColor);
Msg.EnableShadow(FLinearColor::Black);
Canvas.DrawItem(Msg);
// //@TODO: Draws the current value of the rotation (probably want to keep this!)
// if (bManipulating && StaticMeshEditorPtr.Pin()->GetSelectedSocket() == Socket)
// {
// // Figure out the text height
// FTextSizingParameters Parameters(GEngine->GetSmallFont(), 1.0f, 1.0f);
// UCanvas::CanvasStringSize(Parameters, *Socket->SocketName.ToString());
// int32 YL = FMath::TruncToInt(Parameters.DrawYL);
//
// DrawAngles(&Canvas, XPos, YPos + YL,
// Widget->GetCurrentAxis(),
// GetWidgetMode(),
// Socket->RelativeRotation,
// Socket->RelativeLocation);
// }
}
}
}
}
bool FOculusRiftHMD::NeedReAllocateViewportRenderTarget(const FViewport& Viewport)
{
check(IsInGameThread());
if (Settings->IsStereoEnabled())
{
const uint32 InSizeX = Viewport.GetSizeXY().X;
const uint32 InSizeY = Viewport.GetSizeXY().Y;
const FIntPoint RenderTargetSize = Viewport.GetRenderTargetTextureSizeXY();
uint32 NewSizeX = InSizeX, NewSizeY = InSizeY;
CalculateRenderTargetSize(Viewport, NewSizeX, NewSizeY);
if (NewSizeX != RenderTargetSize.X || NewSizeY != RenderTargetSize.Y || (pCustomPresent && pCustomPresent->AreTexturesMarkedAsInvalid()))
{
return true;
}
}
return false;
}
bool FSteamVRHMD::NeedReAllocateViewportRenderTarget(const FViewport& Viewport)
{
check(IsInGameThread());
if (IsStereoEnabled())
{
const uint32 InSizeX = Viewport.GetSizeXY().X;
const uint32 InSizeY = Viewport.GetSizeXY().Y;
FIntPoint RenderTargetSize;
RenderTargetSize.X = Viewport.GetRenderTargetTexture()->GetSizeX();
RenderTargetSize.Y = Viewport.GetRenderTargetTexture()->GetSizeY();
uint32 NewSizeX = InSizeX, NewSizeY = InSizeY;
CalculateRenderTargetSize(Viewport, NewSizeX, NewSizeY);
if (NewSizeX != RenderTargetSize.X || NewSizeY != RenderTargetSize.Y)
{
return true;
}
}
return false;
}
void FLogVisualizer::UpdateCameraPosition(FName RowName, int32 ItemIndes)
{
const FVisualLoggerDBRow& DBRow = FVisualLoggerDatabase::Get().GetRowByName(RowName);
auto &Entries = DBRow.GetItems();
if (DBRow.GetCurrentItemIndex() == INDEX_NONE || Entries.IsValidIndex(DBRow.GetCurrentItemIndex()) == false)
{
return;
}
UWorld* World = GetWorld();
FVector CurrentLocation = Entries[DBRow.GetCurrentItemIndex()].Entry.Location;
FVector Extent(150);
bool bFoundActor = false;
FName OwnerName = Entries[DBRow.GetCurrentItemIndex()].OwnerName;
for (FActorIterator It(World); It; ++It)
{
AActor* Actor = *It;
if (Actor->GetFName() == OwnerName)
{
FVector Orgin;
Actor->GetActorBounds(false, Orgin, Extent);
bFoundActor = true;
break;
}
}
const float DefaultCameraDistance = ULogVisualizerSettings::StaticClass()->GetDefaultObject<ULogVisualizerSettings>()->DefaultCameraDistance;
Extent = Extent.SizeSquared() < FMath::Square(DefaultCameraDistance) ? FVector(DefaultCameraDistance) : Extent;
#if WITH_EDITOR
UEditorEngine *EEngine = Cast<UEditorEngine>(GEngine);
if (GIsEditor && EEngine != NULL)
{
for (auto ViewportClient : EEngine->AllViewportClients)
{
ViewportClient->FocusViewportOnBox(FBox::BuildAABB(CurrentLocation, Extent));
}
}
else if (AVisualLoggerCameraController::IsEnabled(World) && AVisualLoggerCameraController::Instance.IsValid() && AVisualLoggerCameraController::Instance->GetSpectatorPawn())
{
ULocalPlayer* LocalPlayer = Cast<ULocalPlayer>(AVisualLoggerCameraController::Instance->Player);
if (LocalPlayer && LocalPlayer->ViewportClient && LocalPlayer->ViewportClient->Viewport)
{
FViewport* Viewport = LocalPlayer->ViewportClient->Viewport;
FBox BoundingBox = FBox::BuildAABB(CurrentLocation, Extent);
const FVector Position = BoundingBox.GetCenter();
float Radius = BoundingBox.GetExtent().Size();
FViewportCameraTransform ViewTransform;
ViewTransform.TransitionToLocation(Position, nullptr, true);
float NewOrthoZoom;
const float AspectRatio = 1.777777f;
CA_SUPPRESS(6326);
uint32 MinAxisSize = (AspectRatio > 1.0f) ? Viewport->GetSizeXY().Y : Viewport->GetSizeXY().X;
float Zoom = Radius / (MinAxisSize / 2.0f);
NewOrthoZoom = Zoom * (Viewport->GetSizeXY().X*15.0f);
NewOrthoZoom = FMath::Clamp<float>(NewOrthoZoom, 250, MAX_FLT);
ViewTransform.SetOrthoZoom(NewOrthoZoom);
AVisualLoggerCameraController::Instance->GetSpectatorPawn()->TeleportTo(ViewTransform.GetLocation(), ViewTransform.GetRotation(), false, true);
}
}
#endif
}
