FQuat UAnimGraphNode_SkeletalControlBase::ConvertCSRotationToBoneSpace(const USkeletalMeshComponent* SkelComp, FRotator& InCSRotator, FA2CSPose& MeshBases, const FName& BoneName, const EBoneControlSpace Space)
{
FQuat OutQuat = FQuat::Identity;
if (MeshBases.IsValid())
{
int32 MeshBoneIndex = SkelComp->GetBoneIndex(BoneName);
FVector RotAxis;
float RotAngle;
InCSRotator.Quaternion().ToAxisAndAngle(RotAxis, RotAngle);
switch (Space)
{
// World Space, no change in preview window
case BCS_WorldSpace:
case BCS_ComponentSpace:
// Component Space, no change.
OutQuat = InCSRotator.Quaternion();
break;
case BCS_ParentBoneSpace:
{
const int32 ParentIndex = MeshBases.GetParentBoneIndex(MeshBoneIndex);
if (ParentIndex != INDEX_NONE)
{
FTransform ParentTM = MeshBases.GetComponentSpaceTransform(ParentIndex);
ParentTM = ParentTM.Inverse();
//Calculate the new delta rotation
FVector4 BoneSpaceAxis = ParentTM.TransformVector(RotAxis);
FQuat DeltaQuat(BoneSpaceAxis, RotAngle);
DeltaQuat.Normalize();
OutQuat = DeltaQuat;
}
}
break;
case BCS_BoneSpace:
{
FTransform BoneTM = MeshBases.GetComponentSpaceTransform(MeshBoneIndex);
BoneTM = BoneTM.Inverse();
FVector4 BoneSpaceAxis = BoneTM.TransformVector(RotAxis);
//Calculate the new delta rotation
FQuat DeltaQuat(BoneSpaceAxis, RotAngle);
DeltaQuat.Normalize();
OutQuat = DeltaQuat;
}
break;
}
}
return OutQuat;
}
void FDevicePlugin::StartupModule()
{
pDrvIface = new CLSDRVIFACE();
for (int i = 0; i < NUM_SENSORS; i++)
{
recalibQuat[i].W = 1.0;
recalibQuat[i].X = 0.0;
recalibQuat[i].Y = 0.0;
recalibQuat[i].Z = 0.0;
ueCalibQuat[i].W = 1.0;
ueCalibQuat[i].X = 0.0;
ueCalibQuat[i].Y = 0.0;
ueCalibQuat[i].Z = 0.0;
}
FRotator tempRot;
tempRot.Yaw = 0.0;
tempRot.Pitch = -80.0;
tempRot.Roll = 0.0;
ueCalibQuat[0] = tempRot.Quaternion();
ueCalibQuat[0].X *= -1.0;
ueCalibQuat[0].Z *= -1.0;
tempRot.Yaw = -90.0;
tempRot.Pitch = 0.0;
tempRot.Roll = 180.0;
ueCalibQuat[1] = tempRot.Quaternion();
ueCalibQuat[1].X *= -1.0;
ueCalibQuat[1].Z *= -1.0;
tempRot.Yaw = 0.0;
tempRot.Pitch = 80.0;
tempRot.Roll = 180.0;
ueCalibQuat[2] = tempRot.Quaternion();
//ueCalibQuat[2].X *= -1;
tempRot.Yaw = -90.0;
tempRot.Pitch = 0.0;
tempRot.Roll = 0.0;
ueCalibQuat[3] = tempRot.Quaternion();
/*float temp = ueCalibQuat[3].Y;
ueCalibQuat[3].Y = ueCalibQuat[3].Z;
ueCalibQuat[3].Z = temp;*/
//ueCalibQuat[2].X *= -1;
// This code will execute after your module is loaded into memory (but after global variables are initialized, of course.)
}
void FSpriteSelectedSocket::ApplyDelta(const FVector2D& Delta, const FRotator& Rotation, const FVector& Scale3D, FWidget::EWidgetMode MoveMode)
{
if (UPrimitiveComponent* PreviewComponent = PreviewComponentPtr.Get())
{
UObject* AssociatedAsset = const_cast<UObject*>(PreviewComponent->AdditionalStatObject());
if (UPaperSprite* Sprite = Cast<UPaperSprite>(AssociatedAsset))
{
if (FPaperSpriteSocket* Socket = Sprite->FindSocket(SocketName))
{
const bool bDoRotation = (MoveMode == FWidget::WM_Rotate) || (MoveMode == FWidget::WM_TranslateRotateZ);
const bool bDoTranslation = (MoveMode == FWidget::WM_Translate) || (MoveMode == FWidget::WM_TranslateRotateZ);
const bool bDoScale = MoveMode == FWidget::WM_Scale;
if (bDoTranslation)
{
//@TODO: Currently sockets are in unflipped pivot space,
const FVector Delta3D_UU = (PaperAxisX * Delta.X) + (PaperAxisY * -Delta.Y);
const FVector Delta3D = Delta3D_UU * Sprite->GetPixelsPerUnrealUnit();
Socket->LocalTransform.SetLocation(Socket->LocalTransform.GetLocation() + Delta3D);
}
if (bDoRotation)
{
const FRotator CurrentRot = Socket->LocalTransform.GetRotation().Rotator();
FRotator SocketWinding;
FRotator SocketRotRemainder;
CurrentRot.GetWindingAndRemainder(SocketWinding, SocketRotRemainder);
const FQuat ActorQ = SocketRotRemainder.Quaternion();
const FQuat DeltaQ = Rotation.Quaternion();
const FQuat ResultQ = DeltaQ * ActorQ;
const FRotator NewSocketRotRem = FRotator( ResultQ );
FRotator DeltaRot = NewSocketRotRem - SocketRotRemainder;
DeltaRot.Normalize();
const FRotator NewRotation(CurrentRot + DeltaRot);
Socket->LocalTransform.SetRotation(NewRotation.Quaternion());
}
if (bDoScale)
{
const FVector4 LocalSpaceScaleOffset = Socket->LocalTransform.TransformVector(Scale3D);
Socket->LocalTransform.SetScale3D(Socket->LocalTransform.GetScale3D() + LocalSpaceScaleOffset);
}
}
}
}
}
void ADuckTower::Tick(float DeltaSeconds)
{
Super::Tick(DeltaSeconds);
/*
AActor *actor = GetAttachParentActor();
FVector actor2 = UGameplayStatics::GetPlayerController(GetWorld(), 0)->GetControlledPawn()->GetActorLocation();
FRotator newRotation = FRotationMatrix::MakeFromX(actor2 - actor->GetActorLocation()).Rotator();
GetAttachParentActor()->SetActorRotation(newRotation);
GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Yellow, actor->GetName());
*//*
FVector actor2 = UGameplayStatics::GetPlayerController(GetWorld(), 0)->GetControlledPawn()->GetActorLocation();
FVector actor = GetAttachParentActor()->GetActorLocation();
FVector Direction = actor - actor2;
FRotator test = FRotationMatrix::MakeFromX(Direction).Rotator();
GetAttachParentActor()->SetActorRotation(test);
GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Yellow, actor2.ToString());
*/
//GetAttachParentActor()->SetActorLocation(FVector(0.0f, 0.0f, (float)testNumber));
//testNumber += 1.f;
APawn *player = UGameplayStatics::GetPlayerController(GetWorld(), 0)->GetControlledPawn();
FVector actor2 = player->GetActorLocation(); //+ player->GetRootPrimitiveComponent()->GetPhysicsLinearVelocity() *DeltaSeconds * 10;
FVector actor = GetActorLocation();
FVector Direction = actor - actor2;
FRotator test = FRotationMatrix::MakeFromX(Direction).Rotator();
FRotator test2 = FRotator(1.0f, 0.0f, 0.0f);
FRotator finalrot = FRotator(test.Quaternion() * test2.Quaternion());
FVector vec2 = UGameplayStatics::GetPlayerController(GetWorld(), 0)->GetControlledPawn()->GetActorLocation();
FVector vec = GetActorLocation();
float distance = FVector::Dist(actor, actor2);
//finalrot.Pitch -= 10 - distance / 10000 * 10;
//SetActorRotation(finalrot);
TArray<UStaticMeshComponent*> comps;
GetComponents(comps);
/*
for (auto StaticMeshComponent : comps)
{
StaticMeshComponent->SetVisibility(true);
StaticMeshComponent->SetWorldRotation(finalrot);
GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Blue, StaticMeshComponent->GetComponentRotation().ToString());
}*/
if (UGameplayStatics::GetPlayerController(GetWorld(), 0)->WasInputKeyJustPressed(EKeys::I))
{
}
if (shootTimer <= 0.f)
{
Shoot(distance);
shootTimer = 2.f;
}
else
shootTimer -= DeltaSeconds;
//GetAttachParentActor()->GetRootPrimitiveComponent()->AddImpulse(UGameplayStatics::GetPlayerController(GetWorld(), 0)->GetControlledPawn()->GetActorForwardVector());
//GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Yellow, FString::FromInt(testNumber));
//GetAttachParentActor()->SetActorRotation()
}
void ADuckTower::Shoot(float distance)
{
/*
const FName filename = FName(TEXT("Blueprint'/Game/Blueprints/PickUp.PickUp'"));
FVector loc = GetAttachParentActor()->GetActorLocation();
FRotator rot = GetAttachParentActor()->GetActorRotation();
SpawnBP(GetWorld(), (UClass*)LoadObjFromPath<UBlueprint>(&filename), loc, rot);
*/
APawn *player = UGameplayStatics::GetPlayerController(GetWorld(), 1)->GetControlledPawn();
int randomValue = distance / 10000;
FVector vec = player->GetActorLocation() + FVector(FMath::RandRange(-randomValue, randomValue), FMath::RandRange(-randomValue, randomValue), 0.0f); //+ player->GetRootPrimitiveComponent()->GetPhysicsLinearVelocity() *DeltaSeconds * 10;
FVector vec2 = GetActorLocation();
FVector Direction = vec - vec2;
FRotator test = FRotationMatrix::MakeFromX(Direction).Rotator();
FRotator test2 = FRotator(1.0f, 0.0f, 0.0f);
FRotator finalrot = FRotator(test.Quaternion() * test2.Quaternion());
FVector forward = GetActorForwardVector();
finalrot.Roll = -finalrot.Roll;
finalrot.Yaw = -finalrot.Yaw;
finalrot.Pitch = -finalrot.Pitch;
FVector loc = GetActorLocation() + forward * 500.0f;
FRotator rot = GetActorRotation();
AActor* actor = GetWorld()->SpawnActor<AActor>(BulletBlueprint, loc, GetActorRotation());
actor->SetActorScale3D(FVector(3.0f, 3.0f, 3.0f));
//actor->GetRootPrimitiveComponent()->AddImpulse(actor->GetActorForwardVector()* 5000.0f);
//actor->GetRootPrimitiveComponent()->SetPhysicsLinearVelocity(actor->GetActorForwardVector()*10000.0f); //* (distance/10000 * 1.0f));
}
void AActor::EditorApplyRotation(const FRotator& DeltaRotation, bool bAltDown, bool bShiftDown, bool bCtrlDown)
{
if( RootComponent != NULL )
{
const FRotator Rot = RootComponent->GetAttachParent() != NULL ? GetActorRotation() : RootComponent->RelativeRotation;
FRotator ActorRotWind, ActorRotRem;
Rot.GetWindingAndRemainder(ActorRotWind, ActorRotRem);
const FQuat ActorQ = ActorRotRem.Quaternion();
const FQuat DeltaQ = DeltaRotation.Quaternion();
const FQuat ResultQ = DeltaQ * ActorQ;
const FRotator NewActorRotRem = FRotator( ResultQ );
FRotator DeltaRot = NewActorRotRem - ActorRotRem;
DeltaRot.Normalize();
if( RootComponent->GetAttachParent() != NULL )
{
RootComponent->SetWorldRotation( Rot + DeltaRot );
}
else
{
// No attachment. Directly set relative rotation (to support winding)
RootComponent->SetRelativeRotation( Rot + DeltaRot );
}
}
else
{
UE_LOG(LogActor, Warning, TEXT("WARNING: EditorApplyRotation %s has no root component"), *GetName() );
}
}
void ATP_FlyingPawn::NotifyHit(class UPrimitiveComponent* MyComp, class AActor* Other, class UPrimitiveComponent* OtherComp, bool bSelfMoved, FVector HitLocation, FVector HitNormal, FVector NormalImpulse, const FHitResult& Hit)
{
Super::NotifyHit(MyComp, Other, OtherComp, bSelfMoved, HitLocation, HitNormal, NormalImpulse, Hit);
// Deflect along the surface when we collide.
FRotator CurrentRotation = GetActorRotation(RootComponent);
SetActorRotation(FQuat::Slerp(CurrentRotation.Quaternion(), HitNormal.ToOrientationQuat(), 0.025f));
}
void UDebugHandUtility::DebugOrientation(FRotator Orientation, FVector At, float Scale)
{
FRotator rotation = UKismetMathLibrary::ComposeRotators(Orientation, GetComponentRotation());
FVector EndArrow = (UKismetMathLibrary::GetForwardVector(rotation)*Scale) + At;
DrawDebugDirectionalArrow(GetWorld(), At, EndArrow, 5, FColor::Black);
FVector Extent = Scale * FVector(0.2, 0.2, 0.2);
DrawDebugBox(GetWorld(), EndArrow, Extent, rotation.Quaternion(), FColor::Black);
}
void FSimpleHMD::CalculateStereoViewOffset(const enum EStereoscopicPass StereoPassType, const FRotator& ViewRotation, const float WorldToMeters, FVector& ViewLocation)
{
if( StereoPassType != eSSP_FULL)
{
float EyeOffset = 3.20000005f;
const float PassOffset = (StereoPassType == eSSP_LEFT_EYE) ? EyeOffset : -EyeOffset;
ViewLocation += ViewRotation.Quaternion().RotateVector(FVector(0,PassOffset,0));
}
}
int32 GenerateSphylAsSimpleCollision(UStaticMesh* StaticMesh)
{
if (!PromptToRemoveExistingCollision(StaticMesh))
{
return INDEX_NONE;
}
UBodySetup* bs = StaticMesh->BodySetup;
// Calculate bounding box.
FRawMesh RawMesh;
FStaticMeshSourceModel& SrcModel = StaticMesh->SourceModels[0];
SrcModel.RawMeshBulkData->LoadRawMesh(RawMesh);
FSphere sphere;
float length;
FRotator rotation;
FVector unitVec = bs->BuildScale3D;
CalcBoundingSphyl(RawMesh, sphere, length, rotation, unitVec);
// Dont use if radius is zero.
if (sphere.W <= 0.f)
{
FMessageDialog::Open(EAppMsgType::Ok, NSLOCTEXT("UnrealEd", "Prompt_10", "Could not create geometry."));
return INDEX_NONE;
}
// If height is zero, then a sphere would be better (should we just create one instead?)
if (length <= 0.f)
{
length = SMALL_NUMBER;
}
bs->Modify();
// Create new GUID
bs->InvalidatePhysicsData();
FKSphylElem SphylElem;
SphylElem.Center = sphere.Center;
SphylElem.Orientation = rotation.Quaternion();
SphylElem.Radius = sphere.W;
SphylElem.Length = length;
bs->AggGeom.SphylElems.Add(SphylElem);
// refresh collision change back to staticmesh components
RefreshCollisionChange(StaticMesh);
// Mark staticmesh as dirty, to help make sure it gets saved.
StaticMesh->MarkPackageDirty();
StaticMesh->bCustomizedCollision = true; //mark the static mesh for collision customization
return bs->AggGeom.SphylElems.Num() - 1;
}
void AShip::turnShip(float delta){
if (turnDirection == 0)
return;
FRotator rot = FRotator(turnDirection * engines->getTurnSpeed() * delta, 0.f, 0.f);
FTransform transform = GetTransform();
transform.ConcatenateRotation(rot.Quaternion());
transform.NormalizeRotation();
SetActorTransform(transform);
}
void FOSVRHMD::CalculateStereoViewOffset(const EStereoscopicPass StereoPassType, const FRotator& ViewRotation, const float WorldToMeters, FVector& ViewLocation)
{
if (StereoPassType != eSSP_FULL)
{
float EyeOffset = (GetInterpupillaryDistance() * WorldToMeters) / 2.0f;
const float PassOffset = (StereoPassType == eSSP_LEFT_EYE) ? -EyeOffset : EyeOffset;
ViewLocation += ViewRotation.Quaternion().RotateVector(FVector(0, PassOffset, 0));
const FVector vHMDPosition = DeltaControlOrientation.RotateVector(CurHmdPosition);
ViewLocation += vHMDPosition;
}
}
void ACinemotusPlayerController::RelativeTick(float DeltaTime)
{
UPrimitiveComponent* prim = GetPawn()->GetMovementComponent()->UpdatedComponent;
bool SetPrimDirectly = true;
FQuat finalQuat;
if ((currentCaptureState & ECinemotusCaptureState::ERelativeRotation) == ECinemotusCaptureState::ERelativeRotation)
{
FRotator rot = HydraLatestData->controllers[CAM_HAND].angular_velocity;
const FQuat OldRotation = prim->GetComponentQuat();//GetControlRotation().Quaternion(); //TODO: hold onto a quaternion potentially
const FRotator OldRotationRotator = OldRotation.Rotator();
FRotator worldRotator = FRotator(0, DeadZone(rot.Yaw*DeltaTime, 0.0) + addYaw, 0);
FRotator worldRotator1 = FRotator(DeadZone(rot.Pitch*DeltaTime, 0.0), 0, 0);
FRotator localRotator = FRotator(0, 0, DeadZone(rot.Roll*DeltaTime, 0.0));
const FQuat WorldRot = worldRotator.Quaternion();
const FQuat pitchRot = worldRotator1.Quaternion();
const FQuat LocalRot = localRotator.Quaternion();
////This one does roll around local forward, pitch around world right flattened and yaw around world up
//// FQuat finalQuat = pitchRot*WorldRot*((OldRotation*LocalRot));
finalQuat = WorldRot*((OldRotation*LocalRot)*pitchRot);
}
else
{
finalQuat = FRotator(0, addYaw, 0).Quaternion()*prim->GetComponentQuat();
}
SetControlRotation(finalQuat.Rotator());
if (SetPrimDirectly && prim)
{
prim->SetWorldLocationAndRotation(prim->GetComponentLocation(), finalQuat);// not sure need
}
HandleMovementAbs(DeltaTime, (currentCaptureState & ECinemotusCaptureState::ERelativeTranslation) == ECinemotusCaptureState::ERelativeTranslation);
}
void ALeapMotionHandActor::UpdateBones(float DeltaSeconds)
{
if (BoneActors.Num() == 0) { return; }
float CombinedScale = GetCombinedScale();
FLeapMotionDevice* Device = FLeapMotionControllerPlugin::GetLeapDeviceSafe();
if (Device && Device->IsConnected())
{
int BoneArrayIndex = 0;
for (ELeapBone LeapBone = bShowArm ? ELeapBone::Forearm : ELeapBone::Palm; LeapBone <= ELeapBone::Finger4Tip; ((int8&)LeapBone)++)
{
FVector TargetPosition;
FRotator TargetOrientation;
bool Success = Device->GetBonePostionAndOrientation(HandId, LeapBone, TargetPosition, TargetOrientation);
if (Success)
{
// Offset target position & rotation by the SpawnReference actor's transform
FQuat RefQuat = GetRootComponent()->GetComponentRotation().Quaternion();
TargetPosition = RefQuat * TargetPosition * CombinedScale + GetRootComponent()->GetComponentLocation();
TargetOrientation = (RefQuat * TargetOrientation.Quaternion()).Rotator();
// Get current position & rotation
ALeapMotionBoneActor* BoneActor = BoneActors[BoneArrayIndex++];
UPrimitiveComponent* PrimitiveComponent = Cast<UPrimitiveComponent>(BoneActor->GetRootComponent());
if (PrimitiveComponent && PrimitiveComponent->IsSimulatingPhysics())
{
FVector CurrentPositon = PrimitiveComponent->GetComponentLocation();
FRotator CurrentRotation = PrimitiveComponent->GetComponentRotation();
// Compute linear velocity
FVector LinearVelocity = (TargetPosition - CurrentPositon) / DeltaSeconds;
// Compute angular velocity
FVector Axis;
float Angle;
ConvertDeltaRotationsToAxisAngle(CurrentRotation, TargetOrientation, Axis, Angle);
if (Angle > PI) { Angle -= 2 * PI; }
FVector AngularVelcity = Axis * (Angle / DeltaSeconds);
// Apply velocities
PrimitiveComponent->SetPhysicsLinearVelocity(LinearVelocity);
PrimitiveComponent->SetAllPhysicsAngularVelocity(AngularVelcity * 180.0f / PI);
}
}
}
}
}
// Called every frame
void ACPP_VRPawn::Tick(float DeltaTime)
{
Super::Tick(DeltaTime);
FRotator FinalRotation; //final rotation for object
FRotator LHandRotation; //left hand rotation
FRotator RHandRotation; //right hand rotation
FQuat DiffQuat; //difference in rotation between initial and current
//set left item rotation if grabbing
if (bLIsGrabbing)
{
LHandRotation = LeftHand->GetComponentRotation();
//calculate difference in rotation
DiffQuat = LHandRotation.Quaternion() * LInitialHandRotation.GetInverse().Quaternion();
//rotate initial rotation by our difference
FinalRotation = (DiffQuat * LInitialItemRotation.Quaternion()).Rotator();
LPhysHandle->SetTargetLocationAndRotation(LeftHand->GetComponentLocation(), FinalRotation);
}
//set right item rotation if grabbing something
if (bRIsGrabbing)
{
RHandRotation = RightHand->GetComponentRotation();
DiffQuat = RHandRotation.Quaternion() * RInitialHandRotation.GetInverse().Quaternion();
FinalRotation = (DiffQuat * RInitialItemRotation.Quaternion()).Rotator();
RPhysHandle->SetTargetLocationAndRotation(RightHand->GetComponentLocation(), FinalRotation);
}
}
void FSteamVRHMD::ResetOrientation(float Yaw)
{
FRotator ViewRotation;
ViewRotation = FRotator(TrackingFrame.DeviceOrientation[vr::k_unTrackedDeviceIndex_Hmd]);
ViewRotation.Pitch = 0;
ViewRotation.Roll = 0;
if (Yaw != 0.f)
{
// apply optional yaw offset
ViewRotation.Yaw -= Yaw;
ViewRotation.Normalize();
}
BaseOrientation = ViewRotation.Quaternion();
}
void FSteamVRHMD::CalculateStereoViewOffset(const enum EStereoscopicPass StereoPassType, const FRotator& ViewRotation, const float WorldToMeters, FVector& ViewLocation)
{
if( StereoPassType != eSSP_FULL)
{
vr::Hmd_Eye HmdEye = (StereoPassType == eSSP_LEFT_EYE) ? vr::Eye_Left : vr::Eye_Right;
vr::HmdMatrix34_t HeadFromEye = VRSystem->GetEyeToHeadTransform(HmdEye);
// grab the eye position, currently ignoring the rotation supplied by GetHeadFromEyePose()
FVector TotalOffset = FVector(-HeadFromEye.m[2][3], HeadFromEye.m[0][3], HeadFromEye.m[1][3]) * WorldToMeters;
ViewLocation += ViewRotation.Quaternion().RotateVector(TotalOffset);
const FVector vHMDPosition = DeltaControlOrientation.RotateVector(TrackingFrame.DevicePosition[vr::k_unTrackedDeviceIndex_Hmd]);
ViewLocation += vHMDPosition;
}
}
bool FEdModeLevel::InputDelta( FEditorViewportClient* InViewportClient, FViewport* InViewport, FVector& InDrag, FRotator& InRot, FVector& InScale )
{
// Only Update the LevelTransform if the user has clicked on the Widget
if (InViewportClient->GetCurrentWidgetAxis() != EAxisList::None)
{
FVector Translation = LevelTransform.GetTranslation();
Translation += InDrag;
LevelTransform.SetTranslation( Translation );
FRotator Rot = LevelTransform.GetRotation().Rotator();
Rot += InRot;
LevelTransform.SetRotation( Rot.Quaternion() );
return true;
}
return false;
}
void FOSVRHMD::ResetOrientation(float yaw)
{
FRotator ViewRotation;
ViewRotation = FRotator(CurHmdOrientation);
ViewRotation.Pitch = 0;
ViewRotation.Roll = 0;
ViewRotation.Yaw += BaseOrientation.Rotator().Yaw;
if (yaw != 0.f)
{
// apply optional yaw offset
ViewRotation.Yaw -= yaw;
ViewRotation.Normalize();
}
BaseOrientation = ViewRotation.Quaternion();
}
void FComponentEditorUtils::AdjustComponentDelta(USceneComponent* Component, FVector& Drag, FRotator& Rotation)
{
USceneComponent* ParentSceneComp = Component->GetAttachParent();
if (ParentSceneComp)
{
const FTransform ParentToWorldSpace = ParentSceneComp->GetSocketTransform(Component->AttachSocketName);
if (!Component->bAbsoluteLocation)
{
Drag = ParentToWorldSpace.Inverse().TransformVector(Drag);
}
if (!Component->bAbsoluteRotation)
{
Rotation = ( ParentToWorldSpace.Inverse().GetRotation() * Rotation.Quaternion() * ParentToWorldSpace.GetRotation() ).Rotator();
}
}
}
void UGridMovementComponent::TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction *ThisTickFunction)
{
Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
if (Moving)
{
/* Find the next location */
Distance = FMath::Min(Spline->GetSplineLength(), Distance + (MaxSpeed * DeltaTime));
/* Grab our current transform so we can find the velocity if we need it later */
AActor *Owner = GetOwner();
FTransform OldTransform = Owner->GetTransform();
/* Find the next loaction from the spline*/
FTransform NewTransform = Spline->GetTransformAtDistanceAlongSpline(Distance, ESplineCoordinateSpace::Local);
/* Restrain rotation axis */
FRotator Rotation = NewTransform.Rotator();
Rotation.Roll = LockRoll ? 0 : Rotation.Roll;
Rotation.Pitch = LockPitch ? 0 : Rotation.Pitch;
Rotation.Yaw = LockYaw ? 0 : Rotation.Yaw;
NewTransform.SetRotation(Rotation.Quaternion());
Owner->SetActorTransform(NewTransform);
/* Check if we're reached our destination*/
if (Distance >= Spline->GetSplineLength())
{
Moving = false;
Distance = 0;
Velocity = FVector::ZeroVector;
OnMovementEndEvent.Broadcast();
}
else
{
Velocity = (NewTransform.GetLocation() - OldTransform.GetLocation()) * (1 / DeltaTime);
}
// update velocity so it can be fetched by the pawn
UpdateComponentVelocity();
}
}
void FComponentEditorUtils::AdjustComponentDelta(USceneComponent* Component, FVector& Drag, FRotator& Rotation)
{
USceneComponent* ParentSceneComp = Component->GetAttachParent();
if (ParentSceneComp)
{
const FTransform ParentToWorldSpace = ParentSceneComp->GetSocketTransform(Component->AttachSocketName);
if (!Component->bAbsoluteLocation)
{
//transform the drag vector in relative to the parent transform
Drag = ParentToWorldSpace.InverseTransformVectorNoScale(Drag);
//Now that we have a global drag we can apply the parent scale
Drag = Drag * ParentToWorldSpace.Inverse().GetScale3D();
}
if (!Component->bAbsoluteRotation)
{
Rotation = ( ParentToWorldSpace.Inverse().GetRotation() * Rotation.Quaternion() * ParentToWorldSpace.GetRotation() ).Rotator();
}
}
}
void DrawDebugCamera(const UWorld* InWorld, FVector const& Location, FRotator const& Rotation, float FOVDeg, float Scale, FColor const& Color, bool bPersistentLines, float LifeTime, uint8 DepthPriority)
{
static float BaseScale = 4.f;
static FVector BaseProportions(2.f, 1.f, 1.5f);
// no debug line drawing on dedicated server
if (GEngine->GetNetMode(InWorld) != NM_DedicatedServer)
{
DrawDebugCoordinateSystem(InWorld, Location, Rotation, BaseScale*Scale, bPersistentLines, DepthPriority);
FVector Extents = BaseProportions * BaseScale * Scale;
DrawDebugBox(InWorld, Location, Extents, Rotation.Quaternion(), Color, bPersistentLines, LifeTime, DepthPriority); // lifetime
// draw "lens" portion
FRotationTranslationMatrix Axes(Rotation, Location);
FVector XAxis = Axes.GetScaledAxis( EAxis::X );
FVector YAxis = Axes.GetScaledAxis( EAxis::Y );
FVector ZAxis = Axes.GetScaledAxis( EAxis::Z );
FVector LensPoint = Location + XAxis * Extents.X;
float LensSize = BaseProportions.Z * Scale * BaseScale;
float HalfLensSize = LensSize * FMath::Tan(FMath::DegreesToRadians(FOVDeg*0.5f));
FVector Corners[4] =
{
LensPoint + XAxis * LensSize + (YAxis * HalfLensSize) + (ZAxis * HalfLensSize),
LensPoint + XAxis * LensSize + (YAxis * HalfLensSize) - (ZAxis * HalfLensSize),
LensPoint + XAxis * LensSize - (YAxis * HalfLensSize) - (ZAxis * HalfLensSize),
LensPoint + XAxis * LensSize - (YAxis * HalfLensSize) + (ZAxis * HalfLensSize),
};
DrawDebugLine(InWorld, LensPoint, Corners[0], Color, bPersistentLines, LifeTime, DepthPriority);
DrawDebugLine(InWorld, LensPoint, Corners[1], Color, bPersistentLines, LifeTime, DepthPriority);
DrawDebugLine(InWorld, LensPoint, Corners[2], Color, bPersistentLines, LifeTime, DepthPriority);
DrawDebugLine(InWorld, LensPoint, Corners[3], Color, bPersistentLines, LifeTime, DepthPriority);
DrawDebugLine(InWorld, Corners[0], Corners[1], Color, bPersistentLines, LifeTime, DepthPriority);
DrawDebugLine(InWorld, Corners[1], Corners[2], Color, bPersistentLines, LifeTime, DepthPriority);
DrawDebugLine(InWorld, Corners[2], Corners[3], Color, bPersistentLines, LifeTime, DepthPriority);
DrawDebugLine(InWorld, Corners[3], Corners[0], Color, bPersistentLines, LifeTime, DepthPriority);
}
}
void ALeapMotionHandActor::CreateBones(const TSubclassOf<class ALeapMotionBoneActor>& BoneBlueprint)
{
FActorSpawnParameters SpawnParams;
SpawnParams.Owner = GetOwner();
SpawnParams.Instigator = GetInstigator();
float CombinedScale = GetCombinedScale();
FLeapMotionDevice* Device = FLeapMotionControllerPlugin::GetLeapDeviceSafe();
if (Device && Device->IsConnected())
{
for (ELeapBone LeapBone = bShowArm ? ELeapBone::Forearm : ELeapBone::Palm; LeapBone <= ELeapBone::Finger4Tip; ((int8&)LeapBone)++)
{
FVector Position;
FRotator Orientation;
float Width;
float Length;
bool Success = Device->GetBonePostionAndOrientation(HandId, LeapBone, Position, Orientation);
Success &= Device->GetBoneWidthAndLength(HandId, LeapBone, Width, Length);
if (Success)
{
FQuat RefQuat = GetRootComponent()->GetComponentRotation().Quaternion();
Position = RefQuat * Position * CombinedScale + GetRootComponent()->GetComponentLocation();
Orientation = (RefQuat * Orientation.Quaternion()).Rotator();
ALeapMotionBoneActor* BoneActor = GWorld->SpawnActor<ALeapMotionBoneActor>(BoneBlueprint ? BoneBlueprint : ALeapMotionBoneActor::StaticClass(), Position, Orientation, SpawnParams);
if (BoneActor)
{
BoneActors.Add(BoneActor);
# if WITH_EDITOR
BoneActor->SetActorLabel(*FString::Printf(TEXT("LeapBone:%s"), ANSI_TO_TCHAR(LEAP_GET_BONE_NAME(LeapBone))));
# endif
BoneActor->AttachRootComponentToActor(this, NAME_None, EAttachLocation::KeepWorldPosition, true);
BoneActor->Init(LeapBone, CombinedScale, Width, Length, bShowCollider, bShowMesh);
}
}
}
}
}
void FSpriteSelectedShape::ApplyDelta(const FVector2D& Delta, const FRotator& Rotation, const FVector& Scale3D, FWidget::EWidgetMode MoveMode)
{
if (Geometry.Shapes.IsValidIndex(ShapeIndex))
{
FSpriteGeometryShape& Shape = Geometry.Shapes[ShapeIndex];
const bool bDoRotation = (MoveMode == FWidget::WM_Rotate) || (MoveMode == FWidget::WM_TranslateRotateZ);
const bool bDoTranslation = (MoveMode == FWidget::WM_Translate) || (MoveMode == FWidget::WM_TranslateRotateZ);
const bool bDoScale = MoveMode == FWidget::WM_Scale;
if (bDoTranslation)
{
const FVector WorldSpaceDelta = (PaperAxisX * Delta.X) + (PaperAxisY * Delta.Y);
const FVector2D TextureSpaceDelta = EditorContext->SelectedItemConvertWorldSpaceDeltaToLocalSpace(WorldSpaceDelta);
Shape.BoxPosition += TextureSpaceDelta;
Geometry.GeometryType = ESpritePolygonMode::FullyCustom;
}
if (bDoScale)
{
const float ScaleDeltaX = FVector::DotProduct(Scale3D, PaperAxisX);
const float ScaleDeltaY = FVector::DotProduct(Scale3D, PaperAxisY);
const FVector2D OldSize = Shape.BoxSize;
const FVector2D NewSize(OldSize.X + ScaleDeltaX, OldSize.Y + ScaleDeltaY);
if (!FMath::IsNearlyZero(NewSize.X, KINDA_SMALL_NUMBER) && !FMath::IsNearlyZero(NewSize.Y, KINDA_SMALL_NUMBER))
{
const FVector2D ScaleFactor(NewSize.X / OldSize.X, NewSize.Y / OldSize.Y);
Shape.BoxSize = NewSize;
// Now apply it to the verts
for (FVector2D& Vertex : Shape.Vertices)
{
Vertex.X *= ScaleFactor.X;
Vertex.Y *= ScaleFactor.Y;
}
Geometry.GeometryType = ESpritePolygonMode::FullyCustom;
}
}
if (bDoRotation)
{
//@TODO: This stuff should probably be wrapped up into a utility method (also used for socket editing)
const FRotator CurrentRot(Shape.Rotation, 0.0f, 0.0f);
FRotator SocketWinding;
FRotator SocketRotRemainder;
CurrentRot.GetWindingAndRemainder(SocketWinding, SocketRotRemainder);
const FQuat ActorQ = SocketRotRemainder.Quaternion();
const FQuat DeltaQ = Rotation.Quaternion();
const FQuat ResultQ = DeltaQ * ActorQ;
const FRotator NewSocketRotRem = FRotator(ResultQ);
FRotator DeltaRot = NewSocketRotRem - SocketRotRemainder;
DeltaRot.Normalize();
const FRotator NewRotation(CurrentRot + DeltaRot);
Shape.Rotation = NewRotation.Pitch;
Geometry.GeometryType = ESpritePolygonMode::FullyCustom;
}
}
}
bool FPhATEdPreviewViewportClient::InputWidgetDelta( FViewport* InViewport, EAxisList::Type CurrentAxis, FVector& Drag, FRotator& Rot, FVector& Scale )
{
bool bHandled = false;
TArray<FPhATSharedData::FSelection> & SelectedObjects = SharedData->EditingMode == FPhATSharedData::PEM_BodyEdit ? SharedData->SelectedBodies : SharedData->SelectedConstraints;
for(int32 i=0; i<SelectedObjects.Num(); ++i)
{
FPhATSharedData::FSelection & SelectedObject = SelectedObjects[i];
if( SharedData->bManipulating )
{
float BoneScale = 1.f;
if (SharedData->EditingMode == FPhATSharedData::PEM_BodyEdit) /// BODY EDITING ///
{
int32 BoneIndex = SharedData->EditorSkelComp->GetBoneIndex(SharedData->PhysicsAsset->SkeletalBodySetups[SelectedObject.Index]->BoneName);
FTransform BoneTM = SharedData->EditorSkelComp->GetBoneTransform(BoneIndex);
BoneScale = BoneTM.GetScale3D().GetAbsMax();
BoneTM.RemoveScaling();
SelectedObject.WidgetTM = SharedData->EditorSkelComp->GetPrimitiveTransform(BoneTM, SelectedObject.Index, SelectedObject.PrimitiveType, SelectedObject.PrimitiveIndex, BoneScale);
}
else /// CONSTRAINT EDITING ///
{
SelectedObject.WidgetTM = SharedData->GetConstraintMatrix(SelectedObject.Index, EConstraintFrame::Frame2, 1.f);
}
if ( GetWidgetMode() == FWidget::WM_Translate )
{
FVector Dir = SelectedObject.WidgetTM.InverseTransformVector( Drag.GetSafeNormal() );
FVector DragVec = Dir * Drag.Size() / BoneScale;
SelectedObject.ManipulateTM.AddToTranslation( DragVec );
}
else if ( GetWidgetMode() == FWidget::WM_Rotate )
{
FVector Axis;
float Angle;
Rot.Quaternion().ToAxisAndAngle(Axis, Angle);
Axis = SelectedObject.WidgetTM.InverseTransformVectorNoScale( Axis );
const FQuat Start = SelectedObject.ManipulateTM.GetRotation();
const FQuat Delta = FQuat( Axis, Angle );
const FQuat Result = Delta * Start;
SelectedObject.ManipulateTM = FTransform( Result );
}
else if ( GetWidgetMode() == FWidget::WM_Scale && SharedData->EditingMode == FPhATSharedData::PEM_BodyEdit) // Scaling only valid for bodies.
{
ModifyPrimitiveSize(SelectedObject.Index, SelectedObject.PrimitiveType, SelectedObject.PrimitiveIndex, Scale );
}
if (SharedData->EditingMode == FPhATSharedData::PEM_ConstraintEdit)
{
UPhysicsConstraintTemplate* ConstraintSetup = SharedData->PhysicsAsset->ConstraintSetup[SelectedObject.Index];
ConstraintSetup->DefaultInstance.SetRefFrame(EConstraintFrame::Frame2, SelectedObject.ManipulateTM * StartManParentConTM);
//Rotation by default only rotates one frame, but translation by default moves both
bool bMultiFrame = (IsAltPressed() && GetWidgetMode() == FWidget::WM_Rotate) || (!IsAltPressed() && GetWidgetMode() == FWidget::WM_Translate);
if (bMultiFrame)
{
SharedData->SetSelectedConstraintRelTM(StartManRelConTM);
}
else
{
ConstraintSetup->DefaultInstance.SetRefFrame(EConstraintFrame::Frame1, FTransform(StartManChildConTM));
}
}
bHandled = true;
}
}
return bHandled;
}
bool FInstancedStaticMeshSCSEditorCustomization::HandleViewportDrag(class USceneComponent* InSceneComponent, class USceneComponent* InComponentTemplate, const FVector& InDeltaTranslation, const FRotator& InDeltaRotation, const FVector& InDeltaScale, const FVector& InPivot)
{
check(InSceneComponent->IsA(UInstancedStaticMeshComponent::StaticClass()));
UInstancedStaticMeshComponent* InstancedStaticMeshComponentScene = CastChecked<UInstancedStaticMeshComponent>(InSceneComponent);
UInstancedStaticMeshComponent* InstancedStaticMeshComponentTemplate = CastChecked<UInstancedStaticMeshComponent>(InComponentTemplate);
// transform pivot into component's space
const FVector LocalPivot = InstancedStaticMeshComponentScene->GetComponentToWorld().InverseTransformPosition(InPivot);
// Ensure that selected instances are up-to-date
ValidateSelectedInstances(InstancedStaticMeshComponentScene);
bool bMovedInstance = false;
check(InstancedStaticMeshComponentScene->SelectedInstances.Num() == InstancedStaticMeshComponentScene->PerInstanceSMData.Num());
for(int32 InstanceIndex = 0; InstanceIndex < InstancedStaticMeshComponentScene->SelectedInstances.Num(); InstanceIndex++)
{
if (InstancedStaticMeshComponentScene->SelectedInstances[InstanceIndex] && InstancedStaticMeshComponentTemplate->PerInstanceSMData.IsValidIndex(InstanceIndex))
{
FMatrix& MatrixScene = InstancedStaticMeshComponentScene->PerInstanceSMData[InstanceIndex].Transform;
FMatrix& MatrixTemplate = InstancedStaticMeshComponentTemplate->PerInstanceSMData[InstanceIndex].Transform;
FVector Translation = MatrixScene.GetOrigin();
FRotator Rotation = MatrixScene.Rotator();
FVector Scale = MatrixScene.GetScaleVector();
FVector NewTranslation = Translation;
FRotator NewRotation = Rotation;
FVector NewScale = Scale;
if( !InDeltaRotation.IsZero() )
{
NewRotation = FRotator( InDeltaRotation.Quaternion() * Rotation.Quaternion() );
NewTranslation -= LocalPivot;
NewTranslation = FRotationMatrix( InDeltaRotation ).TransformPosition( NewTranslation );
NewTranslation += LocalPivot;
}
NewTranslation += InDeltaTranslation;
if( !InDeltaScale.IsNearlyZero() )
{
const FScaleMatrix ScaleMatrix( InDeltaScale );
FVector DeltaScale3D = ScaleMatrix.TransformPosition( Scale );
NewScale = Scale + DeltaScale3D;
NewTranslation -= LocalPivot;
NewTranslation += ScaleMatrix.TransformPosition( NewTranslation );
NewTranslation += LocalPivot;
}
MatrixScene = FScaleRotationTranslationMatrix(NewScale, NewRotation, NewTranslation);
MatrixTemplate = FScaleRotationTranslationMatrix(NewScale, NewRotation, NewTranslation);
bMovedInstance = true;
}
}
return bMovedInstance;
}
bool UMovementComponent::K2_MoveUpdatedComponent(FVector Delta, FRotator NewRotation, FHitResult& OutHit, bool bSweep, bool bTeleport)
{
return SafeMoveUpdatedComponent(Delta, NewRotation.Quaternion(), bSweep, OutHit, TeleportFlagToEnum(bTeleport));
}
bool FSplineComponentVisualizer::HandleInputDelta(FEditorViewportClient* ViewportClient, FViewport* Viewport, FVector& DeltaTranslate, FRotator& DeltaRotate, FVector& DeltaScale)
{
USplineComponent* SplineComp = GetEditedSplineComponent();
if (SplineComp != nullptr)
{
FInterpCurveVector& SplineInfo = SplineComp->SplineInfo;
FInterpCurveQuat& SplineRotInfo = SplineComp->SplineRotInfo;
FInterpCurveVector& SplineScaleInfo = SplineComp->SplineScaleInfo;
const int32 NumPoints = SplineInfo.Points.Num();
if (SelectedTangentHandle != INDEX_NONE)
{
// When tangent handles are manipulated...
check(SelectedTangentHandle < NumPoints);
if (!DeltaTranslate.IsZero())
{
check(SelectedTangentHandleType != ESelectedTangentHandle::None);
SplineComp->Modify();
FInterpCurvePoint<FVector>& EditedPoint = SplineInfo.Points[SelectedTangentHandle];
const FVector Delta = (SelectedTangentHandleType == ESelectedTangentHandle::Leave) ? DeltaTranslate : -DeltaTranslate;
const FVector Tangent = EditedPoint.LeaveTangent + SplineComp->ComponentToWorld.InverseTransformVector(Delta);
EditedPoint.LeaveTangent = Tangent;
EditedPoint.ArriveTangent = Tangent;
EditedPoint.InterpMode = CIM_CurveUser;
}
}
else
{
// When spline keys are manipulated...
check(LastKeyIndexSelected != INDEX_NONE);
check(LastKeyIndexSelected < NumPoints);
check(SelectedKeys.Num() > 0);
SplineComp->Modify();
if (ViewportClient->IsAltPressed() && bAllowDuplication)
{
OnDuplicateKey();
// Don't duplicate again until we release LMB
bAllowDuplication = false;
}
for (int32 SelectedKeyIndex : SelectedKeys)
{
FInterpCurvePoint<FVector>& EditedPoint = SplineInfo.Points[SelectedKeyIndex];
FInterpCurvePoint<FQuat>& EditedRotPoint = SplineRotInfo.Points[SelectedKeyIndex];
FInterpCurvePoint<FVector>& EditedScalePoint = SplineScaleInfo.Points[SelectedKeyIndex];
if (!DeltaTranslate.IsZero())
{
// Find key position in world space
const FVector CurrentWorldPos = SplineComp->ComponentToWorld.TransformPosition(EditedPoint.OutVal);
// Move in world space
const FVector NewWorldPos = CurrentWorldPos + DeltaTranslate;
// Convert back to local space
EditedPoint.OutVal = SplineComp->ComponentToWorld.InverseTransformPosition(NewWorldPos);
}
if (!DeltaRotate.IsZero())
{
// Set point tangent as user controlled
EditedPoint.InterpMode = CIM_CurveUser;
// Rotate tangent according to delta rotation
FVector NewTangent = SplineComp->ComponentToWorld.GetRotation().RotateVector(EditedPoint.LeaveTangent); // convert local-space tangent vector to world-space
NewTangent = DeltaRotate.RotateVector(NewTangent); // apply world-space delta rotation to world-space tangent
NewTangent = SplineComp->ComponentToWorld.GetRotation().Inverse().RotateVector(NewTangent); // convert world-space tangent vector back into local-space
EditedPoint.LeaveTangent = NewTangent;
EditedPoint.ArriveTangent = NewTangent;
// Rotate spline rotation according to delta rotation
FQuat NewRot = SplineComp->ComponentToWorld.GetRotation() * EditedRotPoint.OutVal; // convert local-space rotation to world-space
NewRot = DeltaRotate.Quaternion() * NewRot; // apply world-space rotation
NewRot = SplineComp->ComponentToWorld.GetRotation().Inverse() * NewRot; // convert world-space rotation to local-space
EditedRotPoint.OutVal = NewRot;
}
if (DeltaScale.X != 0.0f)
{
// Set point tangent as user controlled
EditedPoint.InterpMode = CIM_CurveUser;
const FVector NewTangent = EditedPoint.LeaveTangent * (1.0f + DeltaScale.X);
EditedPoint.LeaveTangent = NewTangent;
EditedPoint.ArriveTangent = NewTangent;
}
if (DeltaScale.Y != 0.0f)
{
// Scale in Y adjusts the scale spline
EditedScalePoint.OutVal.Y *= (1.0f + DeltaScale.Y);
}
if (DeltaScale.Z != 0.0f)
{
// Scale in Z adjusts the scale spline
EditedScalePoint.OutVal.Z *= (1.0f + DeltaScale.Z);
}
}
}
NotifyComponentModified();
return true;
}
return false;
}
void FAnimNode_KinectV2Retarget::EvaluateBoneTransforms(USkeletalMeshComponent* SkelComp, FCSPose<FCompactPose>& MeshBases, TArray<FBoneTransform>& OutBoneTransforms)
{
uint8 i = 0;
if (!KinectBody.bIsTracked)
{
return;
}
const FBoneContainer BoneContainer = MeshBases.GetPose().GetBoneContainer();
FA2CSPose TempPose;
TempPose.AllocateLocalPoses(BoneContainer, SkelComp->LocalAtoms);
for (auto Bone : KinectBody.KinectBones)
{
if (BonesToRetarget[i].IsValid(BoneContainer))
{
auto DeltaTranform = Bone.MirroredJointTransform.GetRelativeTransform(SkelComp->GetBoneTransform(0));
//AxisMeshes[Bone.JointTypeEnd]->SetRelativeLocation(PosableMesh->GetBoneLocationByName(RetargetBoneNames[Bone.JointTypeEnd], EBoneSpaces::ComponentSpace));
auto BoneBaseTransform = DeltaTranform*SkelComp->GetBoneTransform(0);
FRotator PreAdjusmentRotator = BoneBaseTransform.Rotator();
FRotator PostBoneDirAdjustmentRotator = (BoneAdjustments[Bone.JointTypeEnd].BoneDirAdjustment.Quaternion()*PreAdjusmentRotator.Quaternion()).Rotator();
FRotator CompSpaceRotator = (PostBoneDirAdjustmentRotator.Quaternion()*BoneAdjustments[Bone.JointTypeEnd].BoneNormalAdjustment.Quaternion()).Rotator();
FVector Normal, Binormal, Dir;
UKismetMathLibrary::BreakRotIntoAxes(CompSpaceRotator, Normal, Binormal, Dir);
Dir *= BoneAdjustments[Bone.JointTypeEnd].bInvertDir ? -1 : 1;
Normal *= BoneAdjustments[Bone.JointTypeEnd].bInvertNormal ? -1 : 1;
FVector X, Y, Z;
switch (BoneAdjustments[Bone.JointTypeEnd].BoneDirAxis)
{
case EAxis::X:
X = Dir;
break;
case EAxis::Y:
Y = Dir;
break;
case EAxis::Z:
Z = Dir;
break;
default:
;
}
switch (BoneAdjustments[Bone.JointTypeEnd].BoneBinormalAxis)
{
case EAxis::X:
X = Binormal;
break;
case EAxis::Y:
Y = Binormal;
break;
case EAxis::Z:
Z = Binormal;
break;
default:
;
}
switch (BoneAdjustments[Bone.JointTypeEnd].BoneNormalAxis)
{
case EAxis::X:
X = Normal;
break;
case EAxis::Y:
Y = Normal;
break;
case EAxis::Z:
Z = Normal;
break;
default:
;
}
FRotator SwiveledRot = UKismetMathLibrary::MakeRotationFromAxes(X, Y, Z);
SwiveledRot = (SkelComp->GetBoneTransform(0).Rotator().Quaternion()*SwiveledRot.Quaternion()).Rotator();
//PosableMesh->SetBoneRotationByName(RetargetBoneNames[Bone.JointTypeEnd], (PosableMesh->GetBoneTransform(0).Rotator().Quaternion()*SwiveledRot.Quaternion()).Rotator(), EBoneSpaces::ComponentSpace);
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
if (BoneAdjustments[i].bDebugDraw)
{
DrawDebugCoordinateSystem(SkelComp->GetWorld(), SkelComp->GetBoneLocation(BonesToRetarget[i].BoneName), SwiveledRot, 100.f, false, 0.1f);
}
#endif
FCompactPoseBoneIndex CompactPoseBoneToModify = BonesToRetarget[i].GetCompactPoseIndex(BoneContainer);
FTransform NewBoneTM = MeshBases.GetComponentSpaceTransform(CompactPoseBoneToModify);
FAnimationRuntime::ConvertCSTransformToBoneSpace(SkelComp, MeshBases, NewBoneTM, CompactPoseBoneToModify, BCS_ComponentSpace);
const FQuat BoneQuat(SwiveledRot);
NewBoneTM.SetRotation(BoneQuat);
// Convert back to Component Space.
FAnimationRuntime::ConvertBoneSpaceTransformToCS(SkelComp, MeshBases, NewBoneTM, CompactPoseBoneToModify, BCS_ComponentSpace);
FAnimationRuntime::SetSpaceTransform(TempPose, BonesToRetarget[i].BoneIndex, NewBoneTM);
OutBoneTransforms.Add(FBoneTransform(BonesToRetarget[i].GetCompactPoseIndex(BoneContainer), NewBoneTM));
}
++i;
}
}