Today we are going to take a look how to use Spline Components and modify their various properties to allow us to specify custom materials as well as determine how meshes are attached to the spline.
The project files for this video & article can be found on our GitHub page.
Looking at our previous tutorial we know that splines are not terribly hard to work with but there is a bit of magic to having something move along a spline.
The key ingredient in this is the FTimeline. This allows us to keep track of an execution of values across a specific timeframe.
The FTimeline combined with a UCurveFloat gives us all that flexibility. So let’s look at the code to see how this all breaks down.
Looking over the code we can see that as part of the FTimeline definition we are specifying a function that will be executed during the runtime of the timeline.
As you can see the logic is not that scary. We are simply taking the delta time by the lenght of the spline and retrieving that points location and rotation.
This is then applied to our mesh and we prevent the pitch from being corrected so our elevator / platform does not tip as it’s traversing along the spline.
Lastly let’s take a look at the function OnEndMovementTimeline() which is called at the .. you guessed it … end of our timeline.
This function is a great spot to put in logic for things like restarting the movement or reversing the movement by injecting some simple properties into our new object.
For further reading about these topics take a look at the following links:
Today we are going to take a look how to use Spline Components and modify their various properties to allow us to specify custom materials as well as determine how meshes are attached to the spline.
The project files for this video & article can be found on our GitHub page.
So why do we care about splines ? Well splines allow us to construct various objects within our world by providing us with easily extensible and modifiable joined sets of meshes.
Splines can also provide support for navigation by being used as a path for something or someone to move along. In our case though we are going to use it for prop building.
Let’s dive into how to initialize a Spline Component.
// Sets default values
ASplineActor::ASplineActor()
{
// Set this actor to call Tick() every frame. You can turn this off to improve performance if you don't need it.
PrimaryActorTick.bCanEverTick = true;
SplineComponent = CreateDefaultSubobject<USplineComponent>("Spline");
if(SplineComponent)
{
SetRootComponent(SplineComponent);
}
}
With our spline component setup we can proceed with attaching Spline Mesh Components by iterating over the available spline points.
To do this we want to override the OnConstruction method in order to allow us to specify the Spline Mesh Components during the process of modifying our spline within the editor.
Here we end up overwriting the OnConstruction method, ensuring we call the parent’s OnConstruction method before we proceed with any of our code. This method is going to be called when our blueprint is being modified in the editor or manipulated in the level.
To provide greater flexibility in our spline actor we introduce a struct and an enum to let us handle multiple different types of meshes / materials and forward axis definitions for our spline mesh components.
From which we can load the appropriate details and make any necessary checks to determine if our map and the contents are valid.
if(SplineComponent && SplineMeshMap.Num() > 0)
{
// lookup all pertinent values
FSplineMeshDetails* StartMeshDetails = nullptr;
if(SplineMeshMap.Contains(ESplineMeshType::START))
{
StartMeshDetails = SplineMeshMap.Find(ESplineMeshType::START);
}
FSplineMeshDetails* EndMeshDetails = nullptr;
if(SplineMeshMap.Contains(ESplineMeshType::END))
{
EndMeshDetails = SplineMeshMap.Find(ESplineMeshType::END);
}
FSplineMeshDetails* DefaultMeshDetails = nullptr;
if(SplineMeshMap.Contains(ESplineMeshType::DEFAULT))
{
DefaultMeshDetails = SplineMeshMap.Find(ESplineMeshType::DEFAULT);
}
else
{
// exit if we don't have a default mesh to work with
return;
}
}
The spline is made up of spline points that which allow for transformation of the spline component using the level editor but it also provides you with information that we require for our construction script as each spline point can change.
We need to capture these changes by iterating over the spline points and then update your spline component accordingly.
With the object instantiated we can determine which of the meshes we want to assign.
Do we want a mesh at the start of our spline ? Do we want one at the end ? Do we want to apply some in the middle ? This type of logic fits extremely well with assets like pipes, fences, ladders and various other common props that need to be adjusted to fit their environment as well as provide quick work flow.
Here we set some environments to hold our mesh details. We use a UMaterialInterface in order to provide flexibility of using master or instance materials.
Lastly we need to define the starting / ending points as well as the tangents that control the curvature of the spline points along said spline.
This allows the spline to determine the position of our new mesh along that spline so everything appears one after the other as we extend our spline points.
Lastly we specify the collision response for each mesh component. This allows us to specify and register different overlap / hit events for each part of the spline providing a lot of flexbility.
