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;
}
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;
}
void FAssetContextMenu::ExecuteCaptureThumbnail()
{
FViewport* Viewport = GEditor->GetActiveViewport();
if ( ensure(GCurrentLevelEditingViewportClient) && ensure(Viewport) )
{
//have to re-render the requested viewport
FLevelEditorViewportClient* OldViewportClient = GCurrentLevelEditingViewportClient;
//remove selection box around client during render
GCurrentLevelEditingViewportClient = NULL;
Viewport->Draw();
ContentBrowserUtils::CaptureThumbnailFromViewport(Viewport, SelectedAssets);
//redraw viewport to have the yellow highlight again
GCurrentLevelEditingViewportClient = OldViewportClient;
Viewport->Draw();
}
}
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 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);
// }
}
}
}
}
void FSteamVRHMD::UpdateViewport(bool bUseSeparateRenderTarget, const FViewport& InViewport, SViewport* ViewportWidget)
{
check(IsInGameThread());
FRHIViewport* const ViewportRHI = InViewport.GetViewportRHI().GetReference();
if (!IsStereoEnabled())
{
if (!bUseSeparateRenderTarget)
{
ViewportRHI->SetCustomPresent(nullptr);
}
return;
}
GetActiveRHIBridgeImpl()->UpdateViewport(InViewport, ViewportRHI);
}
void FSteamVRHMD::D3D11Bridge::UpdateViewport(const FViewport& Viewport, FRHIViewport* InViewportRHI)
{
check(IsInGameThread());
check(InViewportRHI);
const FTexture2DRHIRef& RT = Viewport.GetRenderTargetTexture();
check(IsValidRef(RT));
if (RenderTargetTexture != nullptr)
{
RenderTargetTexture->Release(); //@todo steamvr: need to also release in reset
}
RenderTargetTexture = (ID3D11Texture2D*)RT->GetNativeResource();
RenderTargetTexture->AddRef();
InViewportRHI->SetCustomPresent(this);
}
void ASECharacterController::Tick(float DeltaSeconds)
{
Super::Tick(DeltaSeconds);
if (auto PS = CastChecked<ASECharacterState>(PlayerState))
{
auto LocalPlayer = CastChecked<ULocalPlayer>(this->Player);
auto ViewportClient = LocalPlayer->ViewportClient;
FViewport* Viewport = ViewportClient->Viewport;
FVector2D ViewportSize;
switch (PS->CursorState)
{
case ECharacterCursorState::Uncontrolled:
this->bShowMouseCursor = true;
Viewport->LockMouseToViewport(false);
Viewport->CaptureMouse(false);
break;
case ECharacterCursorState::Free:
this->bShowMouseCursor = false;
Viewport->LockMouseToViewport(true);
Viewport->CaptureMouse(false);
break;
case ECharacterCursorState::Locked:
this->bShowMouseCursor = false;
Viewport->LockMouseToViewport(true);
Viewport->CaptureMouse(true);
ViewportClient->GetViewportSize(ViewportSize);
const int32 X = static_cast<int32>(ViewportSize.X * 0.5f);
const int32 Y = static_cast<int32>(ViewportSize.Y * 0.5f);
Viewport->SetMouse(X, Y);
break;
}
}
}
void Update(float DeltaSeconds)
{
bool bShouldUpdate = true;
const float CaptureFrequency = 1.0f/(float)GEngine->MatineeScreenshotOptions.MatineeCaptureFPS;
if (CaptureFrequency > 0.f)
{
CurrentAccumSeconds += DeltaSeconds;
if (CurrentAccumSeconds > CaptureFrequency)
{
while (CurrentAccumSeconds > CaptureFrequency)
{
CurrentAccumSeconds -= CaptureFrequency;
}
}
else
{
bShouldUpdate = false;
}
}
if (GIsRequestingExit || !bShouldUpdate || CaptureSlateRenderer)
{
return;
}
if (bMatineeFinished)
{
if (GEngine->MatineeScreenshotOptions.MatineeCaptureType == 0)
{
if (CaptureViewport)
{
CaptureViewport->GetClient()->CloseRequested(CaptureViewport);
}
}
else
{
FViewport* ViewportUsed = GEngine->GameViewport != NULL ? GEngine->GameViewport->Viewport : NULL;
if (ViewportUsed)
{
ViewportUsed->GetClient()->CloseRequested(ViewportUsed);
}
}
StopCapture();
}
else if (bCapturing)
{
// Wait for the directshow thread to finish encoding the last data
GCaptureSyncEvent->Wait();
CaptureViewport->ReadPixels(ViewportColorBuffer, FReadSurfaceDataFlags());
// Allow the directshow thread to encode more data if the event is still available
if ( GCaptureSyncEvent )
{
GCaptureSyncEvent->Trigger();
UE_LOG(LogMovieCapture, Log, TEXT("-----------------START------------------"));
UE_LOG(LogMovieCapture, Log, TEXT(" INCREASE FrameNumber from %d "), FrameNumber);
FrameNumber++;
}
}
else if (bReadyForCapture)
{
CaptureViewport->ReadPixels(ViewportColorBuffer, FReadSurfaceDataFlags());
// Allow the directshow thread to process the pixels we just read
GCaptureSyncEvent->Trigger();
Control->Run();
bReadyForCapture = false;
bCapturing = true;
UE_LOG(LogMovieCapture, Log, TEXT("-----------------START------------------"));
UE_LOG(LogMovieCapture, Log, TEXT(" INCREASE FrameNumber from %d "), FrameNumber);
FrameNumber++;
}
}
void FSpriteGeometryEditingHelper::DrawGeometry_CanvasPass(FViewport& InViewport, const FSceneView& View, FCanvas& Canvas, /*inout*/ int32& YPos, const FLinearColor& GeometryVertexColor, const FLinearColor& NegativeGeometryVertexColor)
{
if (GeometryBeingEdited == nullptr)
{
return;
}
// Calculate the texture-space position of the mouse
const FVector MousePositionWorldSpace = View.PixelToWorld(InViewport.GetMouseX(), InViewport.GetMouseY(), 0);
const FVector2D MousePositionTextureSpace = EditorContext->WorldSpaceToTextureSpace(MousePositionWorldSpace);
//@TODO: Move all of the line drawing to the PDI pass
FSpriteGeometryCollection& Geometry = GetGeometryChecked();
// Display tool help
{
static const FText GeomHelpStr = LOCTEXT("GeomEditHelp", "Shift + click to insert a vertex.\nSelect one or more vertices and press Delete to remove them.\nDouble click a vertex to select a polygon\n");
static const FText GeomClickAddPolygon_NoSubtractive = LOCTEXT("GeomClickAddPolygon_NoSubtractive", "Click to start creating a polygon\n");
static const FText GeomClickAddPolygon_AllowSubtractive = LOCTEXT("GeomClickAddPolygon_AllowSubtractive", "Click to start creating a polygon\nCtrl + Click to start creating a subtractive polygon\n");
static const FText GeomAddVerticesHelpStr = LOCTEXT("GeomClickAddVertices", "Click to add points to the polygon\nDouble-click to add a point and close the shape\nClick again on the first point or press Enter to close the shape\nPress Backspace to remove the last added point or Escape to remove the shape\n");
FLinearColor ToolTextColor = FLinearColor::White;
const FText* HelpStr;
if (IsAddingPolygon())
{
if (AddingPolygonIndex == INDEX_NONE)
{
HelpStr = bAllowSubtractivePolygons ? &GeomClickAddPolygon_AllowSubtractive : &GeomClickAddPolygon_NoSubtractive;
}
else
{
HelpStr = &GeomAddVerticesHelpStr;
}
ToolTextColor = FLinearColor::Yellow;
}
else
{
HelpStr = &GeomHelpStr;
}
FCanvasTextItem TextItem(FVector2D(6, YPos), *HelpStr, GEngine->GetSmallFont(), ToolTextColor);
TextItem.EnableShadow(FLinearColor::Black);
TextItem.Draw(&Canvas);
YPos += 54;
}
const bool bIsHitTesting = Canvas.IsHitTesting();
// Run thru the geometry shapes and draw hit proxies for them
for (int32 ShapeIndex = 0; ShapeIndex < Geometry.Shapes.Num(); ++ShapeIndex)
{
const FSpriteGeometryShape& Shape = Geometry.Shapes[ShapeIndex];
const bool bIsShapeSelected = IsGeometrySelected(FShapeVertexPair(ShapeIndex, INDEX_NONE));
const FLinearColor LineColorRaw = Shape.bNegativeWinding ? NegativeGeometryVertexColor : GeometryVertexColor;
const FLinearColor VertexColor = Shape.bNegativeWinding ? NegativeGeometryVertexColor : GeometryVertexColor;
const FLinearColor LineColor = Shape.IsShapeValid() ? LineColorRaw : FMath::Lerp(LineColorRaw, FLinearColor::Red, 0.8f);
// Draw the circle shape if necessary
if (Shape.ShapeType == ESpriteShapeType::Circle)
{
if (bIsHitTesting)
{
TSharedPtr<FSpriteSelectedShape> Data = MakeShareable(new FSpriteSelectedShape(EditorContext, Geometry, ShapeIndex, /*bIsBackground=*/ false));
Canvas.SetHitProxy(new HSpriteSelectableObjectHitProxy(Data));
}
// Draw the circle
const float RadiusX = Shape.BoxSize.X * 0.5f;
const float RadiusY = Shape.BoxSize.Y * 0.5f;
const float AngleDelta = 2.0f * PI / SpriteEditingConstantsEX::CircleShapeNumSides;
const float LastX = Shape.BoxPosition.X + RadiusX;
const float LastY = Shape.BoxPosition.Y;
FVector2D LastVertexPos = TextureSpaceToScreenSpace(View, FVector2D(LastX, LastY));
for (int32 SideIndex = 0; SideIndex < SpriteEditingConstantsEX::CircleShapeNumSides; SideIndex++)
{
const float X = Shape.BoxPosition.X + RadiusX * FMath::Cos(AngleDelta * (SideIndex + 1));
const float Y = Shape.BoxPosition.Y + RadiusY * FMath::Sin(AngleDelta * (SideIndex + 1));
const FVector2D ScreenPos = TextureSpaceToScreenSpace(View, FVector2D(X, Y));
FCanvasLineItem LineItem(LastVertexPos, ScreenPos);
LineItem.SetColor(bIsShapeSelected ? SpriteEditingConstantsEX::GeometrySelectedColor : LineColor);
LineItem.LineThickness = SpriteEditingConstantsEX::GeometryBorderLineThickness;
Canvas.DrawItem(LineItem);
LastVertexPos = ScreenPos;
}
if (bIsHitTesting)
{
Canvas.SetHitProxy(nullptr);
}
}
// Draw lines connecting the vertices of the shape
for (int32 VertexIndex = 0; VertexIndex < Shape.Vertices.Num(); ++VertexIndex)
{
const int32 NextVertexIndex = (VertexIndex + 1) % Shape.Vertices.Num();
const FVector2D ScreenPos = TextureSpaceToScreenSpace(View, Shape.ConvertShapeSpaceToTextureSpace(Shape.Vertices[VertexIndex]));
const FVector2D NextScreenPos = TextureSpaceToScreenSpace(View, Shape.ConvertShapeSpaceToTextureSpace(Shape.Vertices[NextVertexIndex]));
const bool bIsThisVertexSelected = IsGeometrySelected(FShapeVertexPair(ShapeIndex, VertexIndex));
const bool bIsNextVertexSelected = IsGeometrySelected(FShapeVertexPair(ShapeIndex, NextVertexIndex));
const bool bIsEdgeSelected = bIsShapeSelected || (bIsThisVertexSelected && bIsNextVertexSelected);
// Draw the normal tick
if (bShowNormals)
{
const FVector2D Direction = (NextScreenPos - ScreenPos).GetSafeNormal();
const FVector2D Normal = FVector2D(-Direction.Y, Direction.X);
const FVector2D Midpoint = (ScreenPos + NextScreenPos) * 0.5f;
const FVector2D NormalPoint = Midpoint - Normal * SpriteEditingConstantsEX::GeometryNormalLength;
FCanvasLineItem LineItem(Midpoint, NormalPoint);
LineItem.SetColor(SpriteEditingConstantsEX::GeometryNormalColor);
Canvas.DrawItem(LineItem);
}
// Draw the edge
{
if (bIsHitTesting)
{
TSharedPtr<FSpriteSelectedEdge> Data = MakeShareable(new FSpriteSelectedEdge(EditorContext, Geometry, ShapeIndex, VertexIndex));
Canvas.SetHitProxy(new HSpriteSelectableObjectHitProxy(Data));
}
FCanvasLineItem LineItem(ScreenPos, NextScreenPos);
LineItem.SetColor(bIsEdgeSelected ? SpriteEditingConstantsEX::GeometrySelectedColor : LineColor);
LineItem.LineThickness = SpriteEditingConstantsEX::GeometryBorderLineThickness;
Canvas.DrawItem(LineItem);
if (bIsHitTesting)
{
Canvas.SetHitProxy(nullptr);
}
}
}
// Draw the vertices
for (int32 VertexIndex = 0; VertexIndex < Shape.Vertices.Num(); ++VertexIndex)
{
const FVector2D ScreenPos = TextureSpaceToScreenSpace(View, Shape.ConvertShapeSpaceToTextureSpace(Shape.Vertices[VertexIndex]));
const float X = ScreenPos.X;
const float Y = ScreenPos.Y;
const bool bIsVertexSelected = IsGeometrySelected(FShapeVertexPair(ShapeIndex, VertexIndex));
const bool bIsVertexLastAdded = IsAddingPolygon() && (AddingPolygonIndex == ShapeIndex) && (VertexIndex == Shape.Vertices.Num() - 1);
const bool bNeedHighlightVertex = bIsShapeSelected || bIsVertexSelected || bIsVertexLastAdded;
if (bIsHitTesting)
{
TSharedPtr<FSpriteSelectedVertex> Data = MakeShareable(new FSpriteSelectedVertex(EditorContext, Geometry, ShapeIndex, VertexIndex));
Canvas.SetHitProxy(new HSpriteSelectableObjectHitProxy(Data));
}
const float VertSize = SpriteEditingConstantsEX::GeometryVertexSize;
Canvas.DrawTile(ScreenPos.X - VertSize*0.5f, ScreenPos.Y - VertSize*0.5f, VertSize, VertSize, 0.f, 0.f, 1.f, 1.f, bNeedHighlightVertex ? SpriteEditingConstantsEX::GeometrySelectedColor : VertexColor, GWhiteTexture);
if (bIsHitTesting)
{
Canvas.SetHitProxy(nullptr);
}
}
}
// Draw a preview cursor for the add polygon tool
if (IsAddingPolygon())
{
// Figure out where the mouse is back in screen space
const FVector2D PotentialVertexScreenPos = TextureSpaceToScreenSpace(View, MousePositionTextureSpace);
bool bWillCloseByClicking = false;
if (Geometry.Shapes.IsValidIndex(AddingPolygonIndex))
{
const FSpriteGeometryShape& Shape = Geometry.Shapes[AddingPolygonIndex];
const FLinearColor LineColorRaw = Shape.bNegativeWinding ? NegativeGeometryVertexColor : GeometryVertexColor;
const FLinearColor LineColorValidity = Shape.IsShapeValid() ? LineColorRaw : FMath::Lerp(LineColorRaw, FLinearColor::Red, 0.8f);
const FLinearColor LineColor = FMath::Lerp(LineColorValidity, SpriteEditingConstantsEX::GeometrySelectedColor, 0.2f);
if (Shape.Vertices.Num() > 0)
{
// Draw a line from the last vertex to the potential insertion point for the new one
{
const FVector2D LastScreenPos = TextureSpaceToScreenSpace(View, Shape.ConvertShapeSpaceToTextureSpace(Shape.Vertices[Shape.Vertices.Num() - 1]));
FCanvasLineItem LineItem(LastScreenPos, PotentialVertexScreenPos);
LineItem.SetColor(LineColor);
LineItem.LineThickness = SpriteEditingConstantsEX::GeometryBorderLineThickness;
Canvas.DrawItem(LineItem);
}
// And to the first vertex if there were at least 2
if (Shape.Vertices.Num() >= 2)
{
const FVector2D FirstScreenPos = TextureSpaceToScreenSpace(View, Shape.ConvertShapeSpaceToTextureSpace(Shape.Vertices[0]));
FCanvasLineItem LineItem(PotentialVertexScreenPos, FirstScreenPos);
LineItem.SetColor(LineColor);
LineItem.LineThickness = SpriteEditingConstantsEX::GeometryBorderLineThickness;
Canvas.DrawItem(LineItem);
// Determine how close we are to the first vertex (will we close the shape by clicking)?
bWillCloseByClicking = (Shape.Vertices.Num() >= 3) && (FVector2D::Distance(FirstScreenPos, PotentialVertexScreenPos) < SpriteEditingConstantsEX::AddPolygonVertexWeldScreenSpaceDistance);
}
}
}
// Draw the prospective vert
const float VertSize = SpriteEditingConstantsEX::GeometryVertexSize;
Canvas.DrawTile(PotentialVertexScreenPos.X - VertSize*0.5f, PotentialVertexScreenPos.Y - VertSize*0.5f, VertSize, VertSize, 0.f, 0.f, 1.f, 1.f, SpriteEditingConstantsEX::GeometrySelectedColor, GWhiteTexture);
// Draw a prompt above and to the right of the cursor
static const FText CloseButton(LOCTEXT("ClosePolygonPrompt", "Close"));
static const FText AddButton(LOCTEXT("AddVertexToPolygonPrompt", "+"));
const FText PromptText(bWillCloseByClicking ? CloseButton : AddButton);
FCanvasTextItem PromptTextItem(FVector2D(PotentialVertexScreenPos.X + VertSize, PotentialVertexScreenPos.Y - VertSize), PromptText, GEngine->GetSmallFont(), FLinearColor::White);
PromptTextItem.EnableShadow(FLinearColor::Black);
PromptTextItem.Draw(&Canvas);
}
}
bool FSpriteGeometryEditMode::HandleClick(FEditorViewportClient* InViewportClient, HHitProxy* HitProxy, const FViewportClick& Click)
{
FViewport* Viewport = InViewportClient->Viewport;
const bool bIsCtrlKeyDown = Viewport->KeyState(EKeys::LeftControl) || Viewport->KeyState(EKeys::RightControl);
const bool bIsShiftKeyDown = Viewport->KeyState(EKeys::LeftShift) || Viewport->KeyState(EKeys::RightShift);
const bool bIsAltKeyDown = Viewport->KeyState(EKeys::LeftAlt) || Viewport->KeyState(EKeys::RightAlt);
bool bHandled = false;
const bool bAllowSelectVertex = !(IsEditingGeometry() && SpriteGeometryHelper.IsAddingPolygon()) && !bIsShiftKeyDown;
const bool bClearSelectionModifier = bIsCtrlKeyDown;
const bool bDeleteClickedVertex = bIsAltKeyDown;
const bool bInsertVertexModifier = bIsShiftKeyDown;
HSpriteSelectableObjectHitProxy* SelectedItemProxy = HitProxyCast<HSpriteSelectableObjectHitProxy>(HitProxy);
if (bAllowSelectVertex && (SelectedItemProxy != nullptr))
{
if (!bClearSelectionModifier)
{
SpriteGeometryHelper.ClearSelectionSet();
}
if (bDeleteClickedVertex)
{
// Delete selection
if (const FSpriteSelectedVertex* SelectedVertex = SelectedItemProxy->Data->CastTo<const FSpriteSelectedVertex>(FSelectionTypes::Vertex))
{
SpriteGeometryHelper.ClearSelectionSet();
SpriteGeometryHelper.AddPolygonVertexToSelection(SelectedVertex->ShapeIndex, SelectedVertex->VertexIndex);
SpriteGeometryHelper.DeleteSelectedItems();
}
else if (const FSpriteSelectedShape* SelectedShape = SelectedItemProxy->Data->CastTo<const FSpriteSelectedShape>(FSelectionTypes::GeometryShape))
{
SpriteGeometryHelper.ClearSelectionSet();
SpriteGeometryHelper.AddShapeToSelection(SelectedShape->ShapeIndex);
SpriteGeometryHelper.DeleteSelectedItems();
}
}
else if (Click.GetEvent() == EInputEvent::IE_DoubleClick)
{
// Double click to select a polygon
if (const FSpriteSelectedVertex* SelectedVertex = SelectedItemProxy->Data->CastTo<const FSpriteSelectedVertex>(FSelectionTypes::Vertex))
{
SpriteGeometryHelper.ClearSelectionSet();
SpriteGeometryHelper.AddShapeToSelection(SelectedVertex->ShapeIndex);
}
}
else
{
//@TODO: This needs to be generalized!
if (const FSpriteSelectedEdge* SelectedEdge = SelectedItemProxy->Data->CastTo<const FSpriteSelectedEdge>(FSelectionTypes::Edge))
{
// Add the next vertex defined by this edge
SpriteGeometryHelper.AddPolygonEdgeToSelection(SelectedEdge->ShapeIndex, SelectedEdge->VertexIndex);
}
else if (const FSpriteSelectedVertex* SelectedVertex = SelectedItemProxy->Data->CastTo<const FSpriteSelectedVertex>(FSelectionTypes::Vertex))
{
SpriteGeometryHelper.AddPolygonVertexToSelection(SelectedVertex->ShapeIndex, SelectedVertex->VertexIndex);
}
else if (const FSpriteSelectedShape* SelectedShape = SelectedItemProxy->Data->CastTo<const FSpriteSelectedShape>(FSelectionTypes::GeometryShape))
{
SpriteGeometryHelper.AddShapeToSelection(SelectedShape->ShapeIndex);
}
else
{
SpriteGeometryHelper.SelectItem(SelectedItemProxy->Data);
}
}
bHandled = true;
}
// else if (HWidgetUtilProxy* PivotProxy = HitProxyCast<HWidgetUtilProxy>(HitProxy))
// {
// //const bool bUserWantsPaint = bIsLeftButtonDown && ( !GetDefault<ULevelEditorViewportSettings>()->bLeftMouseDragMovesCamera || bIsCtrlDown );
// //findme
// WidgetAxis = WidgetProxy->Axis;
//
// // Calculate the screen-space directions for this drag.
// FSceneViewFamilyContext ViewFamily( FSceneViewFamily::ConstructionValues( Viewport, GetScene(), EngineShowFlags ));
// FSceneView* View = CalcSceneView(&ViewFamily);
// WidgetProxy->CalcVectors(View, FViewportClick(View, this, Key, Event, HitX, HitY), LocalManipulateDir, WorldManipulateDir, DragX, DragY);
// bHandled = true;
// }
else
{
if (IsEditingGeometry() && !SpriteGeometryHelper.IsAddingPolygon())
{
FSpriteGeometryCollection* Geometry = SpriteGeometryHelper.GetGeometryBeingEdited();
if (bInsertVertexModifier)
{
const FPlane SpritePlane(PaperAxisX, FVector::ZeroVector, PaperAxisY);
const FVector WorldPoint = FMath::LinePlaneIntersection(Click.GetOrigin(), Click.GetOrigin() + Click.GetDirection(), SpritePlane);
const FVector2D SpriteSpaceClickPoint = SpriteGeometryHelper.GetEditorContext()->WorldSpaceToTextureSpace(WorldPoint);
// find a polygon to add vert to
bool bFoundShapeToAddTo = false;
for (TSharedPtr<FSelectedItem> SelectedItemPtr : SpriteGeometryHelper.GetSelectionSet())
{
if (const FSpriteSelectedVertex* SelectedVertex = SelectedItemPtr->CastTo<const FSpriteSelectedVertex>(FSelectionTypes::Vertex)) //@TODO: Inflexible?
{
SpriteGeometryHelper.AddPointToGeometry(SpriteSpaceClickPoint, SelectedVertex->ShapeIndex);
bFoundShapeToAddTo = true;
break;
}
}
if (!bFoundShapeToAddTo)
{
SpriteGeometryHelper.AddPointToGeometry(SpriteSpaceClickPoint);
}
bHandled = true;
}
}
else if (!IsEditingGeometry())
{
// Clicked on the background (missed any proxies), deselect the socket or whatever was selected
SpriteGeometryHelper.ClearSelectionSet();
}
}
return bHandled ? true : FEdMode::HandleClick(InViewportClient, HitProxy, Click);
}
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
}
