Animate Custom Actors in the Unreal Editor

Follow these steps to animate a custom actor in the Unreal^® Editor. Before you start, make sure you that you have Visual Studio^® 2019 and the Vehicle Dynamics Blockset™ Interface for Unreal Engine^® 4 Projects support package installed on your machine. For more information, see Install Support Package and Configure Environment.

Additionally, make sure that:

• You are comfortable coding with C++ in Unreal Engine.

• Your Unreal Editor C++ project contains a skeletal actor mesh. This example uses a bicycle mesh.

  

This examples provides the workflow for animating a bicycle actor. The general workflow is adapted from the Unreal Engine Vehicle User Guide.

Set up Simulink Model

Step 1: Set up Simulink Model

Open a new Simulink^® model and add these blocks:

• Two Ramp blocks

• Constant block

• Simulation 3D Actor Transform Set block

• Simulation 3D Scene Configuration block

Connect and name the blocks as shown.

Step 2: Configure Blocks

Configure blocks with these parameter settings.

Block	Parameter Settings
Simulation 3D Scene Configuration	Scene source — Unreal Editor Project — Name and location of the installed support package project file, for example, C:\Local\AutoVrtlEnv\AutoVrtlEnv.uproject. Scene view — Scene Origin
Simulation 3D Actor Transform Set	Actor Setup tab: Tag for actor in 3D scene, ActorTag — Bike1 Note This tag should match the Unreal Editor tag name in Step 6: Instantiate the Bicycle Actor. Number of parts per actor to set, NumberOfParts — 3 Initial Values tab: Initial array values to translate actor per part, Translation — [0 0 0;0 0 0;0 0 0] Initial array values to rotate actor per part, Rotation — [0 0 0;0 0 0;0 0 0] Initial array values to scale actor per part, Scale — [1 1 1;1 1 1;1 1 1]
Translation Ramp	Slope — [0.35 0 0;0 0 0;0 0 0]
Rotation Ramp	Slope — [0 0 0;0 -pi/5 0;0 -pi/5 0]
Scale Constant	Constant value — [1 1 1;1 1 1;1 1 1]

Set up Unreal Editor to Animate Bicycle

Step 3: Set up Animation Instance

1. In your Simulink model, use the Simulation 3D Scene Configuration block Open Unreal Editor parameter to open the Unreal Editor.

2. Select File > New C++ Class. In the Choose Parent Class dialog box, select Show All Classes. Search for AnimInst. Add the AnimInstance parent class.

   

3. Name the new C++ class SimulinkBikeAnimInst. Click Create Class.

   

   In the Unreal Editor Message dialog box, click No to not open the Output Log.

   

4. In Visual Studio 2019, open the C:\Local\AutoVrtlEnv\AutoVrtlEnv.sln file. Navigate to the SimulinkBikeAnimInst.h and SimulinkBikeAnimInst.h source files.

   

   Edit the files as shown.

   Tip

   For this example, the code includes FWheelRotation and RWheelRotation properties to animate the bicycle wheel rotation. You can add additional properties to animate other parts of the bicycle.

    Code: SimulinkBikeAnimInst.h

   // Copyright 2019 The MathWorks, Inc.
   #pragma once
    
   #include "CoreMinimal.h"
   #include "Animation/AnimInstance.h"
   #include "SimulinkBikeAnimInst.generated.h"
    
   /**
   *
   */
   UCLASS(transient, Blueprintable, hideCategories = AnimInstance, BlueprintType)
   class AUTOVRTLENV_API USimulinkBikeAnimInst : public UAnimInstance
   {
       GENERATED_UCLASS_BODY()
   public:
       UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = WheelRotation)
           float FWheelRotation;
    
       UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = WheelRotation)
           float RWheelRotation;
   };

    Code: SimulinkBikeAnimInst.cpp

   // Copyright 2019 The MathWorks, Inc.
   #include "SimulinkBikeAnimInst.h"
    
   USimulinkBikeAnimInst::USimulinkBikeAnimInst(const FObjectInitializer& ObjectInitializer)
       : Super(ObjectInitializer) {
       FWheelRotation = 0.0f;
       RWheelRotation = 0.0f;
   }

5. Close the Unreal Editor.

6. In Visual Studio, build the solution.

   

Step 4: Create Animation Blueprint

1. In your Simulink model, use the Simulation 3D Scene Configuration block Open Unreal Editor parameter to open the Unreal Editor.

2. In the Unreal Editor, on the Content Browser tab, under View Options, select Show Engine Content and Show Plugin Content.

   

3. Add the animation mesh. On the Content Browser tab, navigate to MathWorksSimulation Content > Vehicles > Bicyclist > Meshes.

   

4. Select Add New > Animation > Animation Blueprint.

   

5. In the Create Animation Blueprint dialog box, select:

   • Parent Class: SimulinkBikeAnimInst

   • Target Skeleton: SK_Bicycle_Skeleton

   

   Click OK.

6. Name the blueprint BikeAnimation. Right-click and select Save.

   

7. Open the BikeAnimation blueprint. Make the connections as shown.

   

   Make sure that you set:

   • Bone to Modify to the correct bone

   • Rotation Mode to Replace Existing

   • Rotation Space to Bone Space

   

8. Compile and save the project.

Step 5: Create Bicycle Actor C++ Class

1. In the Unreal Editor, on the Content Browser tab, under View Options, select Show Engine Content and Show Plugin Content.

   

2. From the MathWorksSimulation C++ Classes folder, select Sim3dActor.

   

   Right-click and select Create C++ class derived from Sim3dActor.

   

   Tip

   If you do not see the MathWorksSimulation C++ Classes folder, use these steps to check that you have the MathWorksSimulation plugin installed and enabled:

   1. In the Unreal Editor toolbar, select Edit > Plugins.

   2. In the Plugins window, verify that the MathWorks Interface plugin is listed in the installed window. If the plugin is not already enabled, select the Enabled check box.

      If you do not see the MathWorks Interface plugin in this window, repeat step 3 in Configure Environment and reopen the editor from Simulink.

   3. Close the editor and reopen it from Simulink.

3. Name the new Sim3dActor BicycleActor. Select Public. Click Create Class.

   

4. In Visual Studio, navigate to BicycleActor.h and BicycleActor.cpp.

   

   Edit the files as shown.

   Tip

   For this example, the code includes logic to animate the bike body (BIKE_BODY), front wheel (FRONT_WHEEL), and rear wheel (REAR_WHEEL). You can add additional logic to animate other parts of the bicycle.

    Code: BicycleActor.h

   // Copyright 2019 The MathWorks, Inc.
   #pragma once
    
   #include "CoreMinimal.h"
   #include "Sim3dActor.h"
   #include "BicycleActor.generated.h"
    
    
   UCLASS()
   class AUTOVRTLENV_API ABicycleActor : public ASim3dActor
   {
       GENERATED_BODY()
    
       // Reference to animation blueprint and skeletal mesh
       UClass* BicycleAnimation;
       USkeletalMesh* BicycleMesh;
    
       //Enum for parts that we want to control from simulink
       enum {
           BIKE_BODY = 0,
           FRONT_WHEEL = 1,
           REAR_WHEEL =2,
           NumberOfParts = 3
       };
       enum {
           X = 0,
           Y = 1,
           Z = 2
       };
       enum {
           PITCH = 0,
           ROLL = 1,
           YAW = 2
       };
    
   public:
       //Containers to receive data from Simulink
       float Translation[NumberOfParts][3];
       float Rotation[NumberOfParts][3];
       float Scale[NumberOfParts][3];
    
       ABicycleActor();
    
       //Override functions for enabling Simulink to control this actor
       virtual void Sim3dInit() override;
       virtual void Sim3dSetup() override;
       virtual void Sim3dStep(float DeltaSeconds) override;
       virtual void Sim3dRelease() override;
    
       //Some helper functions
       void SetMesh(FString MeshRef);
       void SetAnim(FString AnimRef);
    
       //Function to update position/orientation of actor at each step
       virtual void Transform();
    
       // Returns Mesh subobject
       class USkeletalMeshComponent* GetMesh() const;
    
       //Reference to skeletal mesh component
       UPROPERTY(Category = Bicyclist,
           VisibleDefaultsOnly,
           BlueprintReadOnly,
           meta = (AllowPrivateAccess = "true"))
           class USkeletalMeshComponent* Mesh;
    
   protected:
       virtual int GetNumberOfParts() { return (NumberOfParts); }
    
   };
    
   // Returns Mesh subobject
   FORCEINLINE USkeletalMeshComponent* ABicycleActor::GetMesh() const {
       return Mesh;
   }

    Code: BicycleActor.cpp

   // Copyright 2019 The MathWorks, Inc.
   #include "BicycleActor.h"
   #include "SimulinkBikeAnimInst.h"
   #include "AutoVrtlEnv.h"
   #include "Math/UnrealMathUtility.h"
   
   ABicycleActor::ABicycleActor() {
   
   	//Create mesh component
   	Mesh = CreateOptionalDefaultSubobject<USkeletalMeshComponent>(TEXT("ABicycleMesh"));
   	RootComponent = Mesh;
   }
   
   void ABicycleActor::Sim3dInit() {
   	Super::Sim3dInit();
   }
   
   void ABicycleActor::Sim3dSetup() {
   	SetMesh(TEXT("/MathWorksSimulation/Vehicles/Bicyclist/Meshes/SK_Bicycle"));
   	SetAnim(TEXT("/MathWorksSimulation/Vehicles/Bicyclist/Meshes/BikeAnimation.BikeAnimation_C"));
   
   	GetMesh()->SetSkeletalMesh(BicycleMesh);
   	GetMesh()->SetAnimationMode(EAnimationMode::AnimationBlueprint);
   	GetMesh()->SetAnimInstanceClass(BicycleAnimation);
   	Transform();
   }
   
   void ABicycleActor::Sim3dStep(float DeltaTime) {
   	Transform();
   }
   
   void ABicycleActor::Sim3dRelease() {
   	Super::Sim3dRelease();
   }
   
   void ABicycleActor::Transform() {
   	//Initialize
   	int status = 0;
   	FVector ActorLocation;
   	FRotator ActorRotation;
   	FVector ActorScale;
   	USimulinkBikeAnimInst* Animation = NULL;
   	Animation = Cast<USimulinkBikeAnimInst>(GetMesh()->GetAnimInstance());
   
   	//Read data from simulink
   	status = ReadSimulation3DActorTransform(readerTransform, Translation, Rotation, Scale);
   
   	//Set bicycle position and orientation
   	ActorLocation.Set(Translation[BIKE_BODY][X], Translation[BIKE_BODY][Y], Translation[BIKE_BODY][Z]);
   	ActorRotation.Pitch = Rotation[BIKE_BODY][PITCH];
   	ActorRotation.Roll = Rotation[BIKE_BODY][ROLL];
   	ActorRotation.Yaw = Rotation[BIKE_BODY][YAW];
   
   	//Unit conversion from simulink to UE, meteres to cm and radians to degrees
   	ActorLocation = ActorLocation * 100.0f;
   	ActorRotation = FMath::RadiansToDegrees(ActorRotation);
   	ActorScale.Set(Scale[BIKE_BODY][X], Scale[BIKE_BODY][Y], Scale[BIKE_BODY][Z]);
   
   	SetActorLocation(ActorLocation);
   	SetActorRotation(ActorRotation);
   	SetActorScale3D(ActorScale);
   
   	//Set properies in animation blueprint
   	Animation->FWheelRotation = FMath::RadiansToDegrees(Rotation[FRONT_WHEEL][ROLL]);
   	Animation->RWheelRotation = FMath::RadiansToDegrees(Rotation[REAR_WHEEL][ROLL]);
   
   	//Unit conversion from UE to simulink
   	ActorLocation = GetActorLocation();
   	ActorLocation = ActorLocation * .01f;           // cm -> m
   	ActorRotation = GetActorRotation();
   	ActorRotation = FMath::DegreesToRadians(ActorRotation);
   	ActorScale = GetActorScale3D();
   	Translation[BIKE_BODY][X] = ActorLocation.X;
   	Translation[BIKE_BODY][Y] = ActorLocation.Y;
   	Translation[BIKE_BODY][Z] = ActorLocation.Z;
   	Rotation[BIKE_BODY][X] = ActorRotation.Pitch;
   	Rotation[BIKE_BODY][Y] = ActorRotation.Roll;
   	Rotation[BIKE_BODY][Z] = ActorRotation.Yaw;
   	Scale[BIKE_BODY][X] = ActorScale.X;
   	Scale[BIKE_BODY][Y] = ActorScale.Y;
   	Scale[BIKE_BODY][Z] = ActorScale.Z;
   
   	Translation[FRONT_WHEEL][X] = 0.0f;
   	Translation[FRONT_WHEEL][Y] = 0.0f;
   	Translation[FRONT_WHEEL][Z] = 0.0f;
   	Translation[REAR_WHEEL][X] = 0.0f;
   	Translation[REAR_WHEEL][Y] = 0.0f;
   	Translation[REAR_WHEEL][Z] = 0.0f;
   
   	Rotation[FRONT_WHEEL][PITCH] = 0.0f;
   	Rotation[FRONT_WHEEL][ROLL] = FMath::DegreesToRadians(Animation->FWheelRotation);
   	Rotation[FRONT_WHEEL][YAW] = 0.0f;
   	Rotation[REAR_WHEEL][PITCH] = 0.0f;
   	Rotation[REAR_WHEEL][ROLL] = FMath::DegreesToRadians(Animation->RWheelRotation);
   	Rotation[REAR_WHEEL][YAW] = 0.0f;
   
   	Scale[FRONT_WHEEL][X] = 1.0f;
   	Scale[FRONT_WHEEL][Y] = 1.0f;
   	Scale[FRONT_WHEEL][Z] = 1.0f;
   	Scale[REAR_WHEEL][X] = 1.0f;
   	Scale[REAR_WHEEL][Y] = 1.0f;
   	Scale[REAR_WHEEL][Z] = 1.0f;
   
   	//Write data back to simulink
   	WriteSimulation3DActorTransform(writerTransform, Translation, Rotation, Scale);
   }
   
   void ABicycleActor::SetMesh(FString MeshPath) {
   	BicycleMesh =
   		Cast<USkeletalMesh>(StaticLoadObject(USkeletalMesh::StaticClass(), NULL, *MeshPath));
   }
   
   void ABicycleActor::SetAnim(FString AnimPath) {
   	BicycleAnimation = StaticLoadClass(USimulinkBikeAnimInst::StaticClass(), NULL, *AnimPath);
   }

   Tip

   In the code, make sure to use relative paths when you specify the mesh and animation asset locations.

   void ABicycleActor::Sim3dSetup() {
   	SetMesh(TEXT("/MathWorksSimulation/Vehicles/Bicyclist/Meshes/SK_Bicycle"));
   	SetAnim(TEXT("/MathWorksSimulation/Vehicles/Bicyclist/Meshes/BikeAnimation.BikeAnimation_C"));
   
   	GetMesh()->SetSkeletalMesh(BicycleMesh);
   	GetMesh()->SetAnimationMode(EAnimationMode::AnimationBlueprint);
   	GetMesh()->SetAnimInstanceClass(BicycleAnimation);
   	Transform();
   }

5. Close the Unreal Editor.

6. Save the project and build the solution.

   

Step 6: Instantiate the Bicycle Actor

1. In your Simulink model, use the Simulation 3D Scene Configuration block Open Unreal Editor parameter to open the Unreal Editor.

2. Place the Bicycle Actor in the scene.

   

3. Set the tag to the same value as the Simulation 3D Actor Transform Set block Tag for actor in 3D scene, ActorTag. For this example, set the value to Bike1.

   

Set up Camera View (Optional)

Optionally, set up a camera view to override the default view. You can use either Simulink or a level blueprint to set up the camera view. For the recommended option, use Simulink.

Step 7: Use Simulink (Recommended)

To setup a camera view that follows along with the bicycle:

1. Add these blocks to the model.

   • One Ramp block

   • One Add block

   • Three Constant blocks

   • Simulation 3D Actor Transform Set block

   Connect and name the blocks as shown.

   

2. Set these block parameters.

   Block	Parameter Settings
   Simulation 3D Actor Transform Set: Camera Control	Tag for actor in 3D scene, ActorTag — MainCamera1
   CamTranslation	Constant value — [0 -5.1 0.56] Interpret vector parameters as 1-D — off
   CamRotation	Constant value — [0 0 deg2rad(85)] Interpret vector parameters as 1-D — off
   CamScale	Constant value — [1 1 1] Interpret vector parameters as 1-D — off

Step 7: Use Level Blueprint

To override the default camera view:

1. Add a camera actor. Assign it as a child of the BicycleActor.

2. Use the Transform settings to specify the location and viewing angle.

   

3. Open the level blueprint.

   

4. In the level blueprint, make these connections. If you right-click on the Event Graph to find nodes, clear Context Sensitive. If you have a CameraActor, you can drag it to the Event Graph from the World Outliner view in the editor.

   

5. Save the project. Close the Unreal Editor.

Run Simulation

After you configure the Simulink model and Unreal Editor environment, run a simulation.

1. In your Simulink model, make sure that you have set the Simulation 3D Scene Configuration parameters to these values:

   • Scene source — Unreal Editor

   • Project — Name and location of the installed support package project file, for example, C:\Local\AutoVrtlEnv\AutoVrtlEnv.uproject.

   • Scene view — Scene Origin

2. Use the Simulation 3D Scene Configuration block Open Unreal Editor parameter to open the Unreal Editor.

3. Run the simulation.

   1. In the Simulink model, click Run.

      Because the source of the scenes is the project opened in the Unreal Editor, the simulation does not start.

   2. Verify that the Diagnostic Viewer window in Simulink displays this message:

      In the Simulation 3D Scene Configuration block, you set the scene source to 'Unreal Editor'. In Unreal Editor, select 'Play' to view the scene.

      This message confirms that Simulink has instantiated the vehicles and other assets in the Unreal Engine 3D environment.

   3. In the Unreal Editor, click Play. The simulation runs in the scene currently open in the Unreal Editor.