Bad Byte Bootstrap Blues

Calling a Blueprint Delegate via C++ and returning a result.

John Connors — Wed, 22 Jan 2025 09:22:42 +0000

Recently I wrote some C++ code to create and seed volume textures for Unreal. I wanted it to be useable by artists, in a way that looked something like this:

And the body of the function called back to looked like this:

The signature of the callback was

FLinearColor Callback(int X, int Y, int Z)

To use it in C++ I had to declare a delegate type like so:

DECLARE_DYNAMIC_DELEGATE_FourParams(FVolumeTextureSampleCallback, int32, PosX, int32, PosY, int32, PosZ, FLinearColor&, PixelColor);

The gotcha that caused me to bang my head for awhile is that I wass not supposed to use a delegate with a return value, but that the return value was a reference in the last place in the argument list. That let me return the sampled value of the color in the volume to the calling function, via C++ with a blueprintable function that looked like this:

  UFUNCTION(BlueprintCallable, Category = "Sandbox|VolumeTexture")
    UPARAM(DisplayName = "VolumeData") UVolumeTexture* CreateSampledVolumeTextureAsset(
        const FName InName, const FString& AssetPath, int32 InSizeX, int32 InSizeY, int32 InSizeZ,
        const FVolumeTextureSampleCallback& Callback);

Its only a small gotcha, but it seems to crop up a lot on the forums and not get answered so I'm committing the answer here. No doubt it will get scraped and mangled by a dozen AI bots, but hey - at least I tried!

Using Visual Studio Code and other ClangD based Editors with Unreal

John Connors — Sun, 09 Jun 2024 15:45:00 +0100

I very much like Visual Studio Code: as an old Emacs (and Vi!) hand I have a thing about editor responsiveness. I'm convinced there's a sweet spot involving the speed of human cognition and a programs response time, or perhaps I'm just an impatient git.

The problem with Visual Studio Code is that the Microsft C++ plugin and Unreal's Visual Studio Code generator leads to a poor experience.

For non-Unreal based projects I use a thing called ClangD, which when coupled with it's Visual Studio Code plugin which results in very fast autocompletion and project navigation. Orders of magnitude faster than the Microsoft plugin, and catches lots of compilationm errors on the fly, as it's a compilation server compiling your code in the background, and calling you out when you make a mistake. The trouble is, that to do this it needs a compilation database in a file called compile_commands.json, containing the command line used to compile each .cpp file in the project.

The Unreal Engine VSCode generator is not set up to take advantage of this; it breaks the compile_commands.json files into multiple files, each per Unreal build target as an individual C++ project: which suits the Microsoft C++ plugin. However, the Clangd server completely fails to work with it.

After a lot of poking about in the Unreal Build Tool source and writing my own generator, I realised that there is a way to generate a compilation database suitable for the Visual Studio Code ClangD plugin (and other editors that use the compilation database - there are quite a few).

Here is the recipie, as tested with the latest version of 5.4 off github (so, probably 5.4.2)

First and most obviously your Source Code Setting needs to be set to Visual Studio Code in the Unreal Editor.

Secondly, some parameters have to be passed to the Visual Studio Code project generator, to ensure it doesn't try to create it's own Microsoft-centric compilation databases. To do this you need to create an .xml file at %USERPROFILE%\AppData\Roaming\Unreal Engine\UnrealBuildTool called BuildConfiguration.xml - this controls the behavior of Unreal Build Tool. It shuld look like this.

<?xml version="1.0" encoding="utf-8" ?>
<Configuration xmlns="https://www.unrealengine.com/BuildConfiguration">
  <ProjectFileGenerator>
    <Format>VisualStudioCode</Format>
  </ProjectFileGenerator>
    <VSCodeProjectFileGenerator>
        <AddDebugAttachConfig>true</AddDebugAttachConfig>
        <NoCompileCommands>true</NoCompileCommands>
    </VSCodeProjectFileGenerator>
</Configuration>

This stops the Visual Studio Code project file generator creating any compile_command.json files, and also adds a handy debug target for just attching to a process into the Visual Studio Code debug configuration.

So, now, how do you generate the compilation database? Well, there is a mode in the UnrealBuildTool to do exactly that. For some reason, it's not a project file generator, which is a bit strange, but there are probably architectural reasons.

In my case I generate the compilation database with the following batch file - called GenerateClangDatabase.bat - in the root folder of my project engine installation. Sandbox is the name of my generic Sandbox game project. It lives in the Projects\ folder under the Unreal Engine root directory. It's not a foreign project in a .uproject file outside of the engine source tree. I am unsure if this setup will work with those - if anyone does try it and gets it to work, I'd love to know.

dotnet .\Engine\Binaries\DotNet\UnrealBuildTool\UnrealBuildTool.dll -Mode=GenerateProjectFiles SandboxEditor Development Win64
dotnet .\Engine\Binaries\DotNET\UnrealBuildTool\UnrealBuildTool.dll -Mode=GenerateClangDatabase -NoPCH -DisableUnity -NoExecCodeGenActions SandboxEditor Development Win64

The -NoPCH and -DisableUnity command lines appear to be important; the unity build and shared pchs upset the database generator which likes to work file by file. Generating the database takes about 50 seconds on my machine (it's not actually compiling anyting). The -NoExecCodeGenActions prevents the databse generator building some generated files, and speeds up the generation process. So far, the lack of these has not been a problem.

Note also, it is important to use the version of clangd that matches the version of Clang that Epic is currently using - at present, that was version 15, which cam be downloaded here. You have to install your own version of LLVM, and put it on your PATH - do not download the latest version when prompted to by the plugin!

It's somewhat fiddly, I admit - but the results are worth it, in my opinion. VSCode is not an IDE, but this gets it within spitting distance, without sacrificing responsiveness. It's how I like it!

Creating a Component At Edit time

John Connors — Sun, 07 Jan 2024 08:20:21 +0000

I am currently writing quite a bit of editor code that involves creting and attaching components to Actors at Edit time (yes, more procedural geometry). I have noticed there's a lot of information on doing this, but they all have one flaw: the created component does not become visible in the details panel immediately.

The component creation sequence goes something like this:

    HeterogeneousVolumeComponent =
        NewObject<UHeterogeneousVolumeComponent>(this, TEXT("MeshPainterVolumeComponent"));
    if (ensure(HeterogeneousVolumeComponent))
    {
        HeterogeneousVolumeComponent->RegisterComponent();
        HeterogeneousVolumeComponent->AttachToComponent(GetRootComponent(), FAttachmentTransformRules::KeepRelativeTransform);
        HeterogeneousVolumeComponent->CreationMethod = EComponentCreationMethod::Instance;

This is the usual sqeuence, but it has one flaw - the details panel of the actor containing the components is not updated. For that you will need the LevelEditor module. Which is the module that manages all the details panels, scene outliners and other Slate Windows. We could dig into the SLevelEditor instance and find our details panel and refresh it, but fortunately, it seems there's ComponentEdited event which will do it for us.

         FLevelEditorModule* LevelEditorPtr{FModuleManager::Get().LoadModulePtr<FLevelEditorModule>("LevelEditor")};
        if (LevelEditorPtr)
        {
         LevelEditorPtr->BroadcastComponentsEdited();      
        }
    }

And that's it; it's a small change but it makes your tool so much more useable!

Creating a Spline Component from a Polyline in Unreal

John Connors — Sun, 12 Nov 2023 10:34:52 +0000

The Spline Component API in Unreal is a very fat one with lots of methods in it, and it's not entirely clear how to use it at first glance. Like creating a Data Asset Instance, it's a question that crops up and doesn't always get seem to be answered. After a brief bit of experimentation I found it's much easier than it fist appears. Essentially the only function you actually need is AddSplinePointAtIndex(InPoint, AddIdx, ESplineCoordinateSpace::Local);

The main snag with the code below is the fact it's compiled into a game module rather than an editor module and the viewport is not updated when the component is attached to the actor. If you are in editor code, GEditor->RedrawLevelEditingViewports(true); should update the viewport for you, but this won't link in a game module, obviously.

Here is the gist!

/** * Generate a spline we will later use to extrue a road from a set of points */ void ARoadNetwork::GenerateRoadSplines(const TArray& InPoints) { // SplineBeingEdited is an Editor Only property we use to see our new component // in the details panel as it won't show up otherwise #if WITH_EDITORONLY_DATA if (SplineBeingEdited == nullptr) { #endif // create the component USplineComponent* SplineComponent = NewObject(this); #if WITH_EDITORONLY_DATA // ensure it appears in the details panel SplineBeingEdited = SplineComponent; #endif SplineComponent->RegisterComponent(); SplineComponent->ComponentTags.Add(TEXT("Generated")); // set the spline to default state, but with no points SplineComponent->ResetToDefault(); SplineComponent->ClearSplinePoints(); // Iterate over our input points and add spline points to the spline component for (const auto& InPoint : InPoints) { int32 AddIdx = SplineComponent->GetNumberOfSplinePoints(); SplineComponent->AddSplinePointAtIndex(InPoint, AddIdx, ESplineCoordinateSpace::Local); } // ensure spline is updated constexpr bool bUpdateSpline = true; SplineComponent->SetClosedLoop(bUpdateSpline); // attach spline component to root FAttachmentTransformRules Rules(FAttachmentTransformRules::KeepRelativeTransform); SplineComponent->AttachToComponent(RootComponent, Rules); } }

Creating a Data Asset Instance in Blueprint Again

John Connors — Sun, 12 Nov 2023 10:30:34 +0000

It turns out there's a better way to create a Data Asset instance at runtime than the blog I posted earlier, which relied on a function in the Geometry Scripting Library. There is a function in the Asset Tools Library which also creates unique asset names, but in true Epic fashion it's tricky to use and undocumented.

The Asset Tools function, CreateUniqueAssetName is bit of a strange one. It takes a base package name, including an asset name and appends a suffix. If the suffix is numeric and about one, the suffix will auto-increment to the fist available suffix value each time a new asset is created. Which is completely not a use-confounding way to things!

Without further ado, I present the right way to create an asset at edit time without needing an asset fractory, in Blueprint. Hope it helps some poor sod who stumbles on this via their search engine.

You will want to open the image in a new tab to see it in all it's glory!

Creating a Data Asset Instance in Blueprint

John Connors — Fri, 27 Oct 2023 11:23:00 +0100

This is just a quick blog, as I saw some people struggling with this and having to use external plugins to do this, and hope Google will direct people to this, post, eventually!

Creating a Data Asset is possible now, in 5.3. I think this will work with 5.0 upwards, as it relies on the Geometry Script implementation to create a unique asset name and path. You need to enable viewing C++ classes in the content browser to select the data asset class if it's a native class. Also, you do not need a factory, which is just as well as creating a UDataAssetFactory seems to be prolematic in both C++ and Blueprint.

You will want to open the image in a new tab to see it in all it's glory!

Note that I have since updated this with a slightly better method that does not require the Geometry Script Library. More here.

UMG Polyline Editor Widget

John Connors — Mon, 23 Oct 2023 11:27:00 +0100

The Polyline editor I blogged about last time is a Slate Widget; the ultimate goal is to use it as a UMG control as it enables much faster implementation of useful Editor tools like this one

Fortunaely this is an even more straightforward process than the creation of the Slate Control. It derives from UWidget and not UUserWidget. It turns out that UUserWidget is for Blueprint classes to derive from and if you derive from this in C++, the widget will NOT appear in the Widget palette; this behaviour is hardcoded into the engine and was the source of some inital confusion. So, here is the code to achive that!

The properties of the Slate Control that we want to expose to the user are exposed as UProperties. These are passed to the Slate Control in it's constructor as SLATE_ARGUMENTS and the control is constructed in the RebuildWidget method that is overriden from UWidget

Other functions that have to be implemented are ReleaseSlateResources which destroys the Slate Control; SynchronizeProperties which sets the members of the slate control to the values of the UPROPERTIES of the widget, creating a communication conduit from UMG properties to the Slate control members.

One of the members of the widget is an array of points. In the control the points are deleted, modified and created by mouse clicks, so I implemented a sequence of functions in the widget HandlePointAdded, HandlePointRemoved. and HandlePointModified which call multicast delegates for the user of the control to potentially hook in to.

One last function to override is GetPaletteCategory to define what cateogry it appears in, in the UMG Widget palette; I created a new category Geometry because my code is so important, it deserves it's own cateogory like that!

Slate Polyline Editor

John Connors — Tue, 17 Oct 2023 10:27:00 +0100

As I am now, like many of my colleagues in the games industry in the UK, a person of leisure. I have begun to work on some projects of my own. It's very liberating to be free of the commercial constraints of an NDA even if the flip side is the lack of income.

One tool I've wanted to write is making extrusions with geometry script easier to do and design. One of the obvious uses of Geometry Script is to take a profile of some kind and extrude it along a spline. For example a Spline Railing or Spline Walls.

UDynamicMesh* UGeometryScriptLibrary_MeshPrimitiveFunctions::AppendSweepPolygon is a Geometry Script function which will take a polygon descriped as an array of FVector2D and sweep it along a path described as an array of FTransform, which is usually taken from slines (or it can be a sequence of locators, which will have to be the subject of a seperate post).

The trouble is generating that array of FVector2D - there are a bunch of utility functions, like FGeometryScriptPolyPath UGeometryScriptLibrary_PolyPathFunctions::CreateCirclePath2D which will create such things for you based on a regular shape.

However, I wanted the option of submitting a hand-edited shape to Geometry Script, and so wanted a polyline editor, and set out to write one in Slate. Below is a screencap of the result in action.

It proved to be easier than I had feared. The API for drawing thigs in Slate Control is a bit of a construction zone in the engine at the moment, with many functions marked deprecated and many controls in the Engine still using the deprecated functions. It looks like a sizable chunk of tech debt for Epic. I have tried to avoid all these where possible and concentrate on good practice.

As this is not really a tutorial (which would be pohibitively long and basically a tutorial about almsot the entirety of Slate) I shall without further ado, present the code as a pair of gists.

Firstly, the Header

[gist:id=29921c9f20ed74be5cf1c4c2df21b8d5]

Secondly, the Body

// Copyright (C) John Connors 2023 // // Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files(the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and / or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions : // // The above copyright notice and this permission notice shall be included in all copies // or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED “AS IS”, // WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include "SPolylineEditor.h" #include "SlateOptMacros.h" #include "GeometryScript/ShapeFunctions.h" #include const FVector2f SPolylineEditor::PointRadius = FVector2f(8.0f, 8.0f); BEGIN_SLATE_FUNCTION_BUILD_OPTIMIZATION void SPolylineEditor::Construct(const FArguments& InArgs) { Brush = FInvalidatableBrushAttribute(InArgs._Brush); Points = InArgs._Points; LineThickness = InArgs._LineThickness, LineScale = InArgs._LineScale, bClosedLine = InArgs._bClosedLine; bMirror = InArgs._bMirror; ColorAndOpacity = FLinearColor::White; OnPointAdded = InArgs._OnPointAdded; OnPointRemoved = InArgs._OnPointRemoved; OnPointMoved = InArgs._OnPointMoved; PointBeingDragged = INDEX_NONE; } bool SPolylineEditor::IsMirrorVertex(int Index) const { bool bResult = false; if (bMirror) { bResult = (Index >= Points.Num()); if ((bClosedLine) && (Index >= Points.Num() * 2)) { bResult = false; } } return bResult; } void SPolylineEditor::ComputeAllPoints(TArray& AllPoints, bool bIncludeMirrorPoints) const { AllPoints.Reserve(Points.Num() + bClosedLine ? 1 : 0); for (auto& Point : Points) { AllPoints.AddZeroed(); FVector2f& LinePoint = AllPoints.Last(); LinePoint = Point; } if ((bMirror) && (bIncludeMirrorPoints)) { auto PointIt = Points.CreateConstIterator(); auto PointBeginIt = Points.CreateConstIterator(); PointIt.SetToEnd(); do { --PointIt; AllPoints.AddZeroed(); FVector2f& LinePoint = AllPoints.Last(); LinePoint = *PointIt; LinePoint.X = -LinePoint.X; } while (PointIt != PointBeginIt); } if (bClosedLine) { AllPoints.AddZeroed(); AllPoints.Last() = AllPoints[0]; } } void SPolylineEditor::ComputeLinePoints(TArray& LinePoints, const FGeometry& InGeometry, bool bIncludeMirrorPoints) const { const FVector2f Pos = FVector2f::ZeroVector; const FVector2f Size = InGeometry.GetLocalSize(); const FVector2f Center = Pos + 0.5f * Size; LinePoints.Reserve(Points.Num() + bClosedLine ? 1 : 0); FVector2f Scale{ Size.X / (LineScale.X * 2.0f), Size.Y / (LineScale.Y * 2.0f) }; for (auto& Point : Points) { LinePoints.AddZeroed(); FVector2f& LinePoint = LinePoints.Last(); LinePoint = Point * Scale + Center; } if ((bMirror) && (bIncludeMirrorPoints)) { auto PointIt = Points.CreateConstIterator(); auto PointBeginIt = Points.CreateConstIterator(); PointIt.SetToEnd(); do { --PointIt; LinePoints.AddZeroed(); FVector2f& LinePoint = LinePoints.Last(); LinePoint = *PointIt; LinePoint.X = -LinePoint.X; LinePoint = LinePoint * Scale + Center; } while (PointIt != PointBeginIt); } if (bClosedLine) { LinePoints.AddZeroed(); LinePoints.Last() = LinePoints[0]; } } FVector2f SPolylineEditor::MakePoint(const FGeometry& InGeometry, const FVector2f& InPoint) { const FVector2f Pos = FVector2f::ZeroVector; const FVector2f Size = InGeometry.GetLocalSize(); const FVector2f Center = Pos + 0.5f * Size; FVector2f InverseScale{ (LineScale.X * 2.0f) / Size.X , (LineScale.Y * 2.0f) / Size.Y }; return (InPoint - Center) * InverseScale; } FVector2D SPolylineEditor::ComputeDesiredSize(float LayoutScaleMultiplier) const { return FVector2D(LineScale.X * 100.0, LineScale.Y * 100.0); } int32 SPolylineEditor::OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const { const FVector2f Pos = FVector2f::ZeroVector; const FVector2f Size = AllottedGeometry.GetLocalSize(); const FVector2f Center = Pos + 0.5f * Size; //const float Radius = FMath::Min(Size.X, Size.Y) * 0.5f; FSlateColorBrush WhiteBox = FSlateColorBrush(FColor::White); const FSlateBrush* SlateBrush = Brush.GetImage().Get(); FLinearColor LinearColor = GetColorAndOpacity() * InWidgetStyle.GetColorAndOpacityTint() * SlateBrush->GetTint(InWidgetStyle); FColor FinalColorAndOpacity = LinearColor.ToFColor(true); //SLeafWidget::OnPaint(Args, AllottedGeometry, MyCullingRect, OutDrawElements, LayerId, InWidgetStyle, bParentEnabled && IsEnabled()); // Fill the background of the grid const FSlateBrush* BackgroundImage = FAppStyle::GetBrush(TEXT("Graph.Panel.SolidBackground")); FSlateDrawElement::MakeBox(OutDrawElements, LayerId, AllottedGeometry.ToPaintGeometry(), BackgroundImage); if (Points.Num() >= 2) { TArray LinePoints; ComputeLinePoints(LinePoints, AllottedGeometry); const FSlateResourceHandle Handle = FSlateApplication::Get().GetRenderer()->GetResourceHandle(*SlateBrush); FSlateDrawElement::MakeLines(OutDrawElements, LayerId + 1, AllottedGeometry.ToPaintGeometry(), LinePoints, ESlateDrawEffect::NoPixelSnapping, FinalColorAndOpacity, true); const FSlateFontInfo FontInfo = FCoreStyle::GetDefaultFontStyle("Bold", 10); for (int i = 0; i < LinePoints.Num(); i++) { auto Point = LinePoints[i]; FLinearColor BoxColor = IsMirrorVertex(i) ? FLinearColor(FColor::Orange) : FLinearColor::Green; FSlateDrawElement::MakeBox( OutDrawElements, LayerId + 2, AllottedGeometry.ToPaintGeometry(FVector2D(2.f * PointRadius), FSlateLayoutTransform(Point - PointRadius)), &WhiteBox, // bEnabled ? ESlateDrawEffect::None : ESlateDrawEffect::DisabledEffect, ESlateDrawEffect::NoPixelSnapping, BoxColor * FLinearColor(1.f, 1.f, 1.f, 0.25f)); FSlateDrawElement::MakeText(OutDrawElements, LayerId + 3, AllottedGeometry.ToPaintGeometry(FVector2D(2.f * PointRadius), FSlateLayoutTransform(Point - PointRadius)), FString::FromInt(i), FontInfo); } } else { FSlateDrawElement::MakeDebugQuad(OutDrawElements, LayerId, AllottedGeometry.ToPaintGeometry(), FLinearColor::Blue); } return LayerId; } FReply SPolylineEditor::OnMouseButtonDown(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent) { if ((PointBeingDragged == INDEX_NONE) && (MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton)) { const FVector2f LocalCursorPos = UE::Slate::CastToVector2f(MyGeometry.AbsoluteToLocal(MouseEvent.GetScreenSpacePosition())); PointBeingDragged = PointIndexFromCursorPos(MyGeometry, LocalCursorPos, PointRadius.X * PointRadius.X * 2.0f * 2.0f); if (PointBeingDragged != INDEX_NONE) { return FReply::Handled().CaptureMouse(SharedThis(this)); } } return FReply::Unhandled(); } FReply SPolylineEditor::OnMouseButtonUp(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent) { if ((PointBeingDragged != INDEX_NONE) && (MouseEvent.GetEffectingButton() == EKeys::LeftMouseButton)) { const FVector2f LocalCursorPos = UE::Slate::CastToVector2f(MyGeometry.AbsoluteToLocal(MouseEvent.GetScreenSpacePosition())); PointBeingDragged = INDEX_NONE; return FReply::Handled().ReleaseMouseCapture(); } if ((PointBeingDragged == INDEX_NONE) && (MouseEvent.GetEffectingButton() == EKeys::RightMouseButton)) { const FVector2f LocalCursorPos = UE::Slate::CastToVector2f(MyGeometry.AbsoluteToLocal(MouseEvent.GetScreenSpacePosition())); int32 PointToDelete = PointIndexFromCursorPos(MyGeometry, LocalCursorPos, PointRadius.X * PointRadius.X * 2.0f * 2.0f); if (PointToDelete != INDEX_NONE) { Points.RemoveAt(PointToDelete); OnPointMoved.ExecuteIfBound(); } } return FReply::Unhandled(); } FReply SPolylineEditor::OnMouseButtonDoubleClick(const FGeometry& InMyGeometry, const FPointerEvent& InMouseEvent) { if (InMouseEvent.IsMouseButtonDown(EKeys::LeftMouseButton)) { const FVector2f LocalCursorPos = UE::Slate::CastToVector2f(InMyGeometry.AbsoluteToLocal(InMouseEvent.GetScreenSpacePosition())); AddClosestPointAndIndex(InMyGeometry, LocalCursorPos); OnPointAdded.ExecuteIfBound(); return FReply::Handled(); } return FReply::Unhandled(); } FReply SPolylineEditor::OnMouseMove(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent) { if (PointBeingDragged != INDEX_NONE) { const FVector2f LocalCursorPos = UE::Slate::CastToVector2f(MyGeometry.AbsoluteToLocal(MouseEvent.GetScreenSpacePosition())); Points[PointBeingDragged] = MakePoint(MyGeometry, LocalCursorPos); OnPointMoved.ExecuteIfBound(); return FReply::Handled(); } return FReply::Unhandled(); } int32 SPolylineEditor::PointIndexFromCursorPos(const FGeometry& MyGeometry, const FVector2f LocalCursorPos, const float RadiusSquared) { TArray LinePoints; ComputeLinePoints(LinePoints, MyGeometry, false); for (int i = 0; i < LinePoints.Num(); ++i) { const float SizeSquared = (LinePoints[i] - LocalCursorPos).SizeSquared(); if (SizeSquared < RadiusSquared) { return i; } } return INDEX_NONE; } void SPolylineEditor::AddClosestPointAndIndex(const FGeometry& MyGeometry, FVector2f LocalCursorPos) { using URayFuncs = UGeometryScriptLibrary_RayFunctions; auto SignedDistancePointLine2D = [](const FVector2f Point, const FVector2f Start, const FVector2f End) { using FReal = FVector::FReal; auto Cross2D = [](const FVector2f& A, const FVector2f& B) { return A.X * B.Y - A.Y * B.X; }; const FVector2f Seg(End - Start); const FVector2f Dir(Point - Start); const FReal Nom = Cross2D(Seg, Dir); const FReal Den = Seg.SquaredLength(); const FReal Dist = Den > UE_KINDA_SMALL_NUMBER ? (Nom / FMath::Sqrt(Den)) : 0.0; return Dist; }; auto ProjectPointOnSegment2D = [](const FVector2f Point, const FVector2f Start, const FVector2f End) { using FReal = FVector::FReal; const FVector2f Seg(End - Start); const FVector2f Dir(Point - Start); const FReal D = Seg.SquaredLength(); const FReal T = FVector2f::DotProduct(Seg, Dir); if (T < 0.0) { return 0.0; } else if (T > D) { return 1.0; } return D > UE_KINDA_SMALL_NUMBER ? (T / D) : 0.0; }; TArray LinePoints; ComputeLinePoints(LinePoints, MyGeometry, false); int32 NumLinePoints = LinePoints.Num(); int IndexNearest = -1; float ShortestDist = BIG_NUMBER; for (int i = 0; i < NumLinePoints - 1; ++i) { FVector2f PointA(LinePoints[i]); FVector2f PointB(LinePoints[(i + 1) % NumLinePoints]); float Dist = FMath::Abs(SignedDistancePointLine2D(LocalCursorPos, PointA, PointB)); if ((Dist < ShortestDist) && (Dist < PointRadius.X * 2.0)) { ShortestDist = Dist; IndexNearest = i; } } if (IndexNearest == -1) { Points.Add(MakePoint(MyGeometry, LocalCursorPos)); return; } FVector2f PointA = LinePoints[IndexNearest]; FVector2f PointB = LinePoints[(IndexNearest + 1) % NumLinePoints]; float D = ProjectPointOnSegment2D(LocalCursorPos, PointA, PointB); if ((D > KINDA_SMALL_NUMBER) && (D < 1.0f - KINDA_SMALL_NUMBER)) { FVector2f NewLinePoint = (PointB - PointA) * D + PointA; FVector2f NewPoint = MakePoint(MyGeometry, NewLinePoint); Points.Insert(NewPoint, (IndexNearest + 1) % NumLinePoints); } } void SPolylineEditor::SetColorAndOpacity(FLinearColor InColorAndOpacity) { ColorAndOpacity = InColorAndOpacity; } const FLinearColor& SPolylineEditor::GetColorAndOpacity() const { return ColorAndOpacity; } void SPolylineEditor::SetBrush(FSlateBrush* InBrush) { Brush.SetImage(*this, InBrush); } void SPolylineEditor::SetLineScale(FVector2f InScale) { LineScale = InScale; } void SPolylineEditor::SetLineThickness(float InThickness) { LineThickness = InThickness; } const TArray& SPolylineEditor::GetPoints() { return Points; } void SPolylineEditor::SetPoints(const TArray& InPoints) { Points = InPoints; } void SPolylineEditor::SetClosedLine(const bool bInClosedLine) { bClosedLine = bInClosedLine; } void SPolylineEditor::SetMirrored(bool bInMirror) { bMirror = bInMirror; } END_SLATE_FUNCTION_BUILD_OPTIMIZATION

The implementation of drawing in the OnPaint method turned out to be relatively straightforward, after a bit of trial and error. The drawing region is defined by the FGeometry parameter passed to OnPaint. This can be manuiputated as it is converted into PaintGeometry for rendering, to define areas for boxes and text to be rendered in order to add handles to the vertices in the polyline.

For Layout purposes it was important that the Slate control class was derived from SLeafWidget, so no logic to deal with child widgets was needed. ColourAndOpacity could be a straightforward FLinearColor attribute.

Input could be dealt with by overriding OnMouseButtonUp, OnMouseButtonMove. Many parameters are exposed as an attribue as well as delegates tied to the mouse input functions. Ultimately the points used are held in an array of FVector2f which is also an attribute. One wrinkle in all this is that the control has a flag to signal a closed loop or a mirrored set of points. In the case of mirroring the points array actually only holds half the points and the points actually drawn are computed in the ComputePoints function. At the moment the code that consumes the points array needs to be aware of this. Adding a UFUNCTION that computes all the actual points is probably a good idea and left as an exercise for the reader. As is implmenenting a DOOM Wad Editor in Slate..:-)

After this, the next step was to wrap the Slate Control in a UMG widget. Which will be the subject of the next post. Stay Tuned!

Hello World

John Connors — Sun, 22 Jan 2023 17:27:00 +0000

With the impending demise of Twitter, I felt I needed a space to talk to the world about my coding adventures. I have shipped games when most current professional game developers were shipping nappies. A lot has happened, it seems a shame not to share! Most of the content will be Unreal Engine based as I have wrestled with it, in it's various incarnations, but there's likely to be diversions into Python, Lisp, compiler and tool design, and the the game industry.