void FSingleTileEditorViewportClient::DrawCanvas(FViewport& InViewport, FSceneView& View, FCanvas& Canvas)
{
const bool bIsHitTesting = Canvas.IsHitTesting();
if (!bIsHitTesting)
{
Canvas.SetHitProxy(nullptr);
}
int32 YPos = 42;
if (TileBeingEditedIndex != INDEX_NONE)
{
// Draw the collision geometry stats
YPos += 60; //@TODO: Need a better way to determine this from the editor mode
if (bShowStats)
{
bool bHasCollision = false;
if (const FPaperTileMetadata* TileData = TileSet->GetTileMetadata(TileBeingEditedIndex))
{
if (TileData->HasCollision())
{
bHasCollision = true;
FSpriteGeometryEditMode::DrawGeometryStats(InViewport, View, Canvas, TileData->CollisionData, false, /*inout*/ YPos);
}
}
if (!bHasCollision)
{
FCanvasTextItem TextItem(FVector2D(6, YPos), LOCTEXT("NoCollisionDataMainScreen", "No collision data"), GEngine->GetSmallFont(), FLinearColor::White);
TextItem.EnableShadow(FLinearColor::Black);
TextItem.Draw(&Canvas);
}
}
}
FEditorViewportClient::DrawCanvas(InViewport, View, Canvas);
}
void FPhATEdPreviewViewportClient::DrawCanvas( FViewport& InViewport, FSceneView& View, FCanvas& Canvas )
{
if (!PhATPtr.IsValid())
{
return;
}
// Turn on/off the ground box
SharedData->EditorFloorComp->SetVisibility(SharedData->bDrawGround);
float W, H;
PhATFont->GetCharSize(TEXT('L'), W, H);
const float XOffset = 5.0f;
const float YOffset = 32.0f;
FCanvasTextItem TextItem( FVector2D::ZeroVector, FText::GetEmpty(), PhATFont, FLinearColor::White );
// Write body/constraint count at top.
FString StatusString = FText::Format(
NSLOCTEXT("UnrealEd", "BodiesConstraints_F", "{0} Bodies {1} Considered for bounds {2} Ratio {3} Constraints"),
FText::AsNumber(SharedData->PhysicsAsset->SkeletalBodySetups.Num()),
FText::AsNumber(SharedData->PhysicsAsset->BoundsBodies.Num()),
FText::AsNumber(static_cast<float>(SharedData->PhysicsAsset->BoundsBodies.Num())/static_cast<float>(SharedData->PhysicsAsset->SkeletalBodySetups.Num())),
FText::AsNumber(SharedData->PhysicsAsset->ConstraintSetup.Num()) ).ToString();
TextItem.Text = FText::FromString( StatusString );
Canvas.DrawItem( TextItem, XOffset, YOffset);
TextItem.Text = FText::GetEmpty();
if (SharedData->bRunningSimulation)
{
#if PLATFORM_MAC
TextItem.Text = NSLOCTEXT("UnrealEd", "Sim_Mac", "SIM: Command+RightMouse to interact with bodies");
#else
TextItem.Text = NSLOCTEXT("UnrealEd", "Sim", "SIM: Ctrl+RightMouse to interact with bodies");
#endif
}
else if (SharedData->bSelectionLock)
{
TextItem.Text = NSLOCTEXT("UnrealEd", "Lock", "LOCK");
}else if(SharedData->EditingMode == FPhATSharedData::PEM_ConstraintEdit)
{
if(GetWidgetMode() == FWidget::WM_Translate)
{
TextItem.Text = NSLOCTEXT("UnrealEd", "SingleMove", "hold ALT to move a single reference frame");
}else if(GetWidgetMode() == FWidget::WM_Rotate)
{
TextItem.Text = NSLOCTEXT("UnrealEd", "DoubleRotate", "hold ALT to rotate both reference frames");
}
}
Canvas.DrawItem( TextItem, XOffset, Viewport->GetSizeXY().Y - (3 + H) );
// Draw current physics weight
if (SharedData->bRunningSimulation)
{
FString PhysWeightString = FString::Printf(TEXT("Phys Blend: %3.0f pct"), SharedData->EditorSimOptions->PhysicsBlend * 100.f);
int32 PWLW, PWLH;
StringSize(PhATFont, PWLW, PWLH, *PhysWeightString);
TextItem.Text = FText::FromString(PhysWeightString);
Canvas.DrawItem( TextItem, Viewport->GetSizeXY().X - (3 + PWLW + 2*W), Viewport->GetSizeXY().Y - (3 + H) );
}
int32 HalfX = (Viewport->GetSizeXY().X-XOffset)/2;
int32 HalfY = Viewport->GetSizeXY().Y/2;
if ((SharedData->bShowHierarchy && SharedData->EditorSimOptions->bShowNamesInHierarchy))
{
// Iterate over each graphics bone.
for (int32 i = 0; i < SharedData->EditorSkelComp->GetNumComponentSpaceTransforms(); ++i)
{
FVector BonePos = SharedData->EditorSkelComp->ComponentToWorld.TransformPosition(SharedData->EditorSkelComp->GetComponentSpaceTransforms()[i].GetLocation());
FPlane proj = View.Project(BonePos);
if (proj.W > 0.f) // This avoids drawing bone names that are behind us.
{
int32 XPos = HalfX + (HalfX * proj.X);
int32 YPos = HalfY + (HalfY * (proj.Y * -1));
FName BoneName = SharedData->EditorSkelMesh->RefSkeleton.GetBoneName(i);
FColor BoneNameColor = FColor::White;
//iterate through selected bones and see if any match
for(int32 j=0; j< SharedData->SelectedBodies.Num(); ++j)
{
int32 SelectedBodyIndex = SharedData->SelectedBodies[j].Index;
FName SelectedBoneName = SharedData->PhysicsAsset->SkeletalBodySetups[SelectedBodyIndex]->BoneName;
if(SelectedBoneName == BoneName)
{
BoneNameColor = FColor::Green;
break;
}
}
if (Canvas.IsHitTesting())
{
Canvas.SetHitProxy(new HPhATEdBoneNameProxy(i));
}
TextItem.Text = FText::FromString(BoneName.ToString());
TextItem.SetColor(BoneNameColor);
Canvas.DrawItem( TextItem, XPos, YPos );
if (Canvas.IsHitTesting())
{
Canvas.SetHitProxy(NULL);
}
}
}
}
// If showing center-of-mass, and physics is started up..
if (SharedData->bShowCOM)
{
// iterate over each bone
for (int32 i = 0; i <SharedData->EditorSkelComp->Bodies.Num(); ++i)
{
FBodyInstance* BodyInst = SharedData->EditorSkelComp->Bodies[i];
check(BodyInst);
FVector BodyCOMPos = BodyInst->GetCOMPosition();
float BodyMass = BodyInst->GetBodyMass();
FPlane Projection = View.Project(BodyCOMPos);
if (Projection.W > 0.f) // This avoids drawing bone names that are behind us.
{
int32 XPos = HalfX + (HalfX * Projection.X);
int32 YPos = HalfY + (HalfY * (Projection.Y * -1));
FString COMString = FString::Printf(TEXT("%3.3f"), BodyMass);
TextItem.Text = FText::FromString(COMString);
TextItem.SetColor(SharedData->COMRenderColor);
Canvas.DrawItem( TextItem, XPos, YPos );
}
}
}
}
void FSpriteEditorViewportClient::DrawSourceRegion(FViewport& InViewport, FSceneView& View, FCanvas& Canvas, const FLinearColor& GeometryVertexColor)
{
const bool bIsHitTesting = Canvas.IsHitTesting();
UPaperSprite* Sprite = GetSpriteBeingEdited();
const float CornerCollisionVertexSize = 8.0f;
const float EdgeCollisionVertexSize = 6.0f;
const FLinearColor GeometryLineColor(GeometryVertexColor.R, GeometryVertexColor.G, GeometryVertexColor.B, 0.5f * GeometryVertexColor.A);
const bool bDrawEdgeHitProxies = true;
const bool bDrawCornerHitProxies = true;
FVector2D BoundsVertices[4];
BoundsVertices[0] = SourceTextureSpaceToScreenSpace(View, Sprite->SourceUV);
BoundsVertices[1] = SourceTextureSpaceToScreenSpace(View, Sprite->SourceUV + FVector2D(Sprite->SourceDimension.X, 0));
BoundsVertices[2] = SourceTextureSpaceToScreenSpace(View, Sprite->SourceUV + FVector2D(Sprite->SourceDimension.X, Sprite->SourceDimension.Y));
BoundsVertices[3] = SourceTextureSpaceToScreenSpace(View, Sprite->SourceUV + FVector2D(0, Sprite->SourceDimension.Y));
if (bShowNamesForSprites)
{
const FVector2D TextPos = SourceTextureSpaceToScreenSpace(View, Sprite->SourceUV + FVector2D(Sprite->SourceDimension.X*0.5f, Sprite->SourceDimension.Y*0.5f));
const FText AssetNameText = FText::AsCultureInvariant(Sprite->GetName());
FCanvasTextItem TextItem(TextPos, AssetNameText, GEngine->GetSmallFont(), FLinearColor::White);
TextItem.EnableShadow(FLinearColor::Black);
TextItem.bCentreX = true;
TextItem.bCentreY = true;
TextItem.Draw(&Canvas);
}
for (int32 VertexIndex = 0; VertexIndex < 4; ++VertexIndex)
{
const int32 NextVertexIndex = (VertexIndex + 1) % 4;
// Draw the edge
if (bIsHitTesting)
{
TSharedPtr<FSpriteSelectedSourceRegion> Data = MakeShareable(new FSpriteSelectedSourceRegion());
Data->SpritePtr = Sprite;
Data->VertexIndex = 4 + VertexIndex;
Canvas.SetHitProxy(new HSpriteSelectableObjectHitProxy(Data));
}
FCanvasLineItem LineItem(BoundsVertices[VertexIndex], BoundsVertices[NextVertexIndex]);
LineItem.SetColor(GeometryVertexColor);
Canvas.DrawItem(LineItem);
// Add edge hit proxy
if (bDrawEdgeHitProxies)
{
const FVector2D MidPoint = (BoundsVertices[VertexIndex] + BoundsVertices[NextVertexIndex]) * 0.5f;
Canvas.DrawTile(MidPoint.X - EdgeCollisionVertexSize*0.5f, MidPoint.Y - EdgeCollisionVertexSize*0.5f, EdgeCollisionVertexSize, EdgeCollisionVertexSize, 0.f, 0.f, 1.f, 1.f, GeometryVertexColor, GWhiteTexture);
}
if (bIsHitTesting)
{
Canvas.SetHitProxy(nullptr);
}
// Add corner hit proxy
if (bDrawCornerHitProxies)
{
const FVector2D CornerPoint = BoundsVertices[VertexIndex];
if (bIsHitTesting)
{
TSharedPtr<FSpriteSelectedSourceRegion> Data = MakeShareable(new FSpriteSelectedSourceRegion());
Data->SpritePtr = Sprite;
Data->VertexIndex = VertexIndex;
Canvas.SetHitProxy(new HSpriteSelectableObjectHitProxy(Data));
}
Canvas.DrawTile(CornerPoint.X - CornerCollisionVertexSize * 0.5f, CornerPoint.Y - CornerCollisionVertexSize * 0.5f, CornerCollisionVertexSize, CornerCollisionVertexSize, 0.f, 0.f, 1.f, 1.f, GeometryVertexColor, GWhiteTexture);
if (bIsHitTesting)
{
Canvas.SetHitProxy(nullptr);
}
}
}
}
void FSpriteEditorViewportClient::DrawCanvas(FViewport& Viewport, FSceneView& View, FCanvas& Canvas)
{
const bool bIsHitTesting = Canvas.IsHitTesting();
if (!bIsHitTesting)
{
Canvas.SetHitProxy(nullptr);
}
if (!SpriteEditorPtr.IsValid())
{
return;
}
UPaperSprite* Sprite = GetSpriteBeingEdited();
int32 YPos = 42;
static const FText SourceRegionHelpStr = LOCTEXT("SourceRegionHelp", "Drag handles to adjust source region\nDouble-click on an image region to select all connected pixels (Ctrl creates a new sprite)\nHold down Ctrl and drag a rectangle to create a new sprite at that position\nClick on other sprite rectangles to change the active sprite");
switch (CurrentMode)
{
case ESpriteEditorMode::ViewMode:
default:
// Display the pivot
{
FNumberFormattingOptions NoDigitGroupingFormat;
NoDigitGroupingFormat.UseGrouping = false;
const FText PivotStr = FText::Format(LOCTEXT("PivotPosition", "Pivot: ({0}, {1})"), FText::AsNumber(Sprite->CustomPivotPoint.X, &NoDigitGroupingFormat), FText::AsNumber(Sprite->CustomPivotPoint.Y, &NoDigitGroupingFormat));
FCanvasTextItem TextItem(FVector2D(6, YPos), PivotStr, GEngine->GetSmallFont(), FLinearColor::White);
TextItem.EnableShadow(FLinearColor::Black);
TextItem.Draw(&Canvas);
YPos += 18;
}
// Baked collision data
if (Sprite->BodySetup != nullptr)
{
FSpriteGeometryEditMode::DrawCollisionStats(Viewport, View, Canvas, Sprite->BodySetup, /*inout*/ YPos);
}
// Baked render data
DrawRenderStats(Viewport, View, Canvas, Sprite, /*inout*/ YPos);
// And bounds
DrawBoundsAsText(Viewport, View, Canvas, /*inout*/ YPos);
break;
case ESpriteEditorMode::EditCollisionMode:
{
// Draw the collision geometry stats
YPos += 60; //@TODO: Need a better way to determine this from the editor mode
if (Sprite->BodySetup != nullptr)
{
FSpriteGeometryEditMode::DrawGeometryStats(Viewport, View, Canvas, Sprite->CollisionGeometry, false, /*inout*/ YPos);
FSpriteGeometryEditMode::DrawCollisionStats(Viewport, View, Canvas, Sprite->BodySetup, /*inout*/ YPos);
}
else
{
FCanvasTextItem TextItem(FVector2D(6, YPos), LOCTEXT("NoCollisionDataMainScreen", "No collision data"), GEngine->GetSmallFont(), FLinearColor::White);
TextItem.EnableShadow(FLinearColor::Black);
TextItem.Draw(&Canvas);
}
}
break;
case ESpriteEditorMode::EditRenderingGeomMode:
{
// Draw the render geometry stats
YPos += 60; //@TODO: Need a better way to determine this from the editor mode
FSpriteGeometryEditMode::DrawGeometryStats(Viewport, View, Canvas, Sprite->RenderGeometry, true, /*inout*/ YPos);
DrawRenderStats(Viewport, View, Canvas, Sprite, /*inout*/ YPos);
// And bounds
DrawBoundsAsText(Viewport, View, Canvas, /*inout*/ YPos);
}
break;
case ESpriteEditorMode::EditSourceRegionMode:
{
// Display tool help
{
FCanvasTextItem TextItem(FVector2D(6, YPos), SourceRegionHelpStr, GEngine->GetSmallFont(), FLinearColor::White);
TextItem.EnableShadow(FLinearColor::Black);
TextItem.Draw(&Canvas);
YPos += 18;
}
if (bShowRelatedSprites)
{
DrawRelatedSprites(Viewport, View, Canvas, SpriteEditingConstants::SourceRegionRelatedBoundsColor, SpriteEditingConstants::SourceRegionRelatedSpriteNameColor);
}
DrawSourceRegion(Viewport, View, Canvas, SpriteEditingConstants::SourceRegionBoundsColor);
}
break;
}
if (bShowSockets && !IsInSourceRegionEditMode())
{
FSpriteGeometryEditMode* GeometryEditMode = ModeTools->GetActiveModeTyped<FSpriteGeometryEditMode>(FSpriteGeometryEditMode::EM_SpriteGeometry);
FSocketEditingHelper::DrawSocketNames(GeometryEditMode, RenderSpriteComponent, Viewport, View, Canvas);
}
FEditorViewportClient::DrawCanvas(Viewport, View, Canvas);
}
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);
}
}
