Документация

// 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;
};

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

// 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;
}

// Copyright 2019-2021 The MathWorks, Inc.
#include "BicycleActor.h"
#include "SimulinkBikeAnimInst.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);
}