void UCheatManager::Teleport()
{
FVector ViewLocation;
FRotator ViewRotation;
check(GetOuterAPlayerController() != NULL);
GetOuterAPlayerController()->GetPlayerViewPoint( ViewLocation, ViewRotation );
FHitResult Hit;
APawn* AssociatedPawn = GetOuterAPlayerController()->GetPawn();
static FName NAME_TeleportTrace = FName(TEXT("TeleportTrace"));
FCollisionQueryParams TraceParams(NAME_TeleportTrace, true, AssociatedPawn);
bool bHit = GetWorld()->LineTraceSingle(Hit, ViewLocation, ViewLocation + 1000000.f * ViewRotation.Vector(), ECC_Pawn, TraceParams);
if ( bHit )
{
Hit.Location += Hit.Normal * 4.0f;
}
if (AssociatedPawn != NULL)
{
AssociatedPawn->TeleportTo( Hit.Location, AssociatedPawn->GetActorRotation() );
}
else
{
ADebugCameraController* const DCC = Cast<ADebugCameraController>(GetOuter());
if ((DCC != NULL) && (DCC->OriginalControllerRef != NULL))
{
APawn* OriginalControllerPawn = DCC->OriginalControllerRef->GetPawn();
if (OriginalControllerPawn != NULL)
{
OriginalControllerPawn->TeleportTo(Hit.Location, OriginalControllerPawn->GetActorRotation());
}
}
}
}
// Read motion data from Axis Neuron
// Deprecated
bool UPerceptionNeuronBPLibrary::NeuronReadMotion(APerceptionNeuronController *Controller, FVector& Translation, FRotator& Rotation, FVector AdditionalTranslation, FRotator AdditionalRotation, int32 BoneIndex, ENeuronSkeletonEnum SkeletonType)
{
if (Controller == nullptr)
{
if (GEngine)
{
GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("Controller is invalid.")));
}
Rotation.Yaw = Rotation.Pitch = Rotation.Roll = 0;
Translation.X = Translation.Y = Translation.Z = 0;
return false;
}
else if ((Controller->bConnected == false) && (Controller->bPlay == false))
{
Rotation.Yaw = Rotation.Pitch = Rotation.Roll = 0;
Translation.X = Translation.Y = Translation.Z = 0;
return false;
}
else if (BoneIndex >= Controller->Skeleton.BoneNr)
{
if (GEngine)
{
GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("Boneindex %d exceeds maximum available bones %d."), BoneIndex, Controller->Skeleton.BoneNr));
}
Rotation.Yaw = Rotation.Pitch = Rotation.Roll = 0;
Translation.X = Translation.Y = Translation.Z = 0;
return false;
}
int32 FloatsPerBone = 6; // 3 for x,y,z translation and 3 for x,y,z rotation
if (Controller->bDisplacement == false)
{
FloatsPerBone = 3; // If there is no displacement (translation) info we have only 3 floats for rotation left
}
if ((BoneIndex * FloatsPerBone) > Controller->FloatCount)
{
Rotation.Yaw = Rotation.Pitch = Rotation.Roll = 0;
Translation.X = Translation.Y = Translation.Z = 0;
return false;
}
//
// Translation
//
if (Controller->bDisplacement == true)
{
// Read translation values and remove BVH reference position
float X = Controller->MotionLine[(BoneIndex * FloatsPerBone) + Controller->Skeleton.Bones[BoneIndex].XPos] - Controller->Skeleton.Bones[BoneIndex].Offset[0];
float Y = Controller->MotionLine[(BoneIndex * FloatsPerBone) + Controller->Skeleton.Bones[BoneIndex].YPos] - Controller->Skeleton.Bones[BoneIndex].Offset[1];
float Z = Controller->MotionLine[(BoneIndex * FloatsPerBone) + Controller->Skeleton.Bones[BoneIndex].ZPos] - Controller->Skeleton.Bones[BoneIndex].Offset[2];
// Map BVH right hand system to local bone coordinate system
switch (SkeletonType)
{
case ENeuronSkeletonEnum::VE_Neuron: // Neuron BVH skeleton
{
if (BoneIndex == 0)
{ // Hips
Translation = FVector(X, -Y, Z);
}
else if ((BoneIndex >= 1) && (BoneIndex <= 6))
{ // Legs
Translation = FVector(X, Y, -Z);
}
else if ((BoneIndex >= 7) && (BoneIndex <= 12))
{ // Spine,...
Translation = FVector(X, -Y, -Z);
}
else if ((BoneIndex >= 13) && (BoneIndex <= 35))
{ // Right arm
Translation = FVector(-Z, X, Y);
}
else if ((BoneIndex >= 36) && (BoneIndex <= 58))
{ // Left arm
Translation = FVector(Z, -X, Y);
}
break;
}
case ENeuronSkeletonEnum::VE_TPP_Hero: // Hero_TPP, Old blue Unreal default skeleton with T-Pose
case ENeuronSkeletonEnum::VE_Mannequin: // Mannequin, New Unreal default skeleton with A-Pose
{
if (BoneIndex == 0)
{ // Hips
Translation = FVector(Y, Z, -X);
}
// Ignore other bones
break;
}
case ENeuronSkeletonEnum::VE_Map: // Map to configured bone map
{
// Map translation with configured Bonemap
float Map[3] = { X, Y, Z };
Translation = FVector(Map[Controller->Bonemap[BoneIndex].XYZ[0]] * Controller->Bonemap[BoneIndex].Sign[0],
Map[Controller->Bonemap[BoneIndex].XYZ[1]] * Controller->Bonemap[BoneIndex].Sign[1],
Map[Controller->Bonemap[BoneIndex].XYZ[2]] * Controller->Bonemap[BoneIndex].Sign[2]);
break;
}
case ENeuronSkeletonEnum::VE_UE4: // Map to UE4 world coordinate system
{
Translation = FVector(X, Z, Y);
break;
}
case ENeuronSkeletonEnum::VE_None: // Map to nothing, use BVH translation as it is
default:
{
Translation = FVector(X, Y, Z);
break;
}
}
}
else
{
Translation.X = Translation.Y = Translation.Z = 0;
}
// Add additional translation
Translation.X += AdditionalTranslation.X;
Translation.Y += AdditionalTranslation.Y;
Translation.Z += AdditionalTranslation.Z;
//
// Rotation
//
// Read rotation values and map to pitch, yaw, roll (y, z, x)
float XR = Controller->MotionLine[(BoneIndex * FloatsPerBone) + Controller->Skeleton.Bones[BoneIndex].XRot] * PI / 180.f;
float YR = Controller->MotionLine[(BoneIndex * FloatsPerBone) + Controller->Skeleton.Bones[BoneIndex].YRot] * PI / 180.f;
float ZR = Controller->MotionLine[(BoneIndex * FloatsPerBone) + Controller->Skeleton.Bones[BoneIndex].ZRot] * PI / 180.f;
// Calculate Rotation Matrix and map to Quaternion
FQuat Quat = CalculateQuat(XR, YR, ZR, Controller->Skeleton.Bones[BoneIndex].RotOrder);
// Map BVH coordinate system to each bone coordinate system dependend on skeleton type
switch (SkeletonType)
{
case ENeuronSkeletonEnum::VE_Neuron: // Neuron BVH skeleton
{
if ((BoneIndex >= 1) && (BoneIndex <= 6))
{ // Legs
Quat.Z *= -1.f;
}
else if ((BoneIndex >= 13) && (BoneIndex <= 35))
{ // Right Arm
float X = Quat.X;
float Y = Quat.Y;
float Z = Quat.Z;
Quat.X = -Z;
Quat.Y = X;
Quat.Z = Y;
}
else if ((BoneIndex >= 36) && (BoneIndex <= 58))
{ // Left Arm
float X = Quat.X;
float Y = Quat.Y;
float Z = Quat.Z;
Quat.X = Z;
Quat.Y = -X;
Quat.Z = Y;
}
else
{
Quat.Y *= -1.f;
}
break;
}
case ENeuronSkeletonEnum::VE_TPP_Hero: // Hero_TPP, Old blue Unreal default skeleton with T-Pose
case ENeuronSkeletonEnum::VE_Mannequin: // Mannequin, New Unreal default skeleton with A-Pose
{
if ((BoneIndex >= 1) && (BoneIndex <= 3))
{ // Right Leg
float X = Quat.X;
float Y = Quat.Y;
float Z = Quat.Z;
Quat.X = -Y;
Quat.Y = -Z;
Quat.Z = -X;
}
else if (BoneIndex == 16)
{ // Right Hand
Quat.Y *= -1.f;
}
else if ((BoneIndex >= 13) && (BoneIndex <= 19))
{ // Right Arm and Thumb
float Y = Quat.Y;
float Z = Quat.Z;
Quat.Y = -Z;
Quat.Z = -Y;
}
else if ((BoneIndex >= 20) && (BoneIndex <= 35))
{ // Right Finger
Quat.Y *= -1.f;
}
else if (BoneIndex == 39)
{ // Left Hand
Quat.Z *= -1.f;
}
else if ((BoneIndex >= 36) && (BoneIndex <= 42))
{ // Left Arm and Thumb
float Y = Quat.Y;
float Z = Quat.Z;
Quat.Y = Z;
Quat.Z = Y;
}
else if ((BoneIndex >= 43) && (BoneIndex <= 58))
{ // Left Finger
Quat.Z *= -1.f;
}
else
{ // Left Leg, Hips, Spine, Neck, Head
float X = Quat.X;
float Y = Quat.Y;
float Z = Quat.Z;
Quat.X = Y;
Quat.Y = Z;
Quat.Z = -X;
}
break;
}
case ENeuronSkeletonEnum::VE_Map: // Map to configured bone map
{
// Map Quat.X/Y/Z with configured Bonemap
float Map[3] = { Quat.X, Quat.Y, Quat.Z };
Quat.X = Map[Controller->Bonemap[BoneIndex].XYZ[0]] * Controller->Bonemap[BoneIndex].Sign[0];
Quat.Y = Map[Controller->Bonemap[BoneIndex].XYZ[1]] * Controller->Bonemap[BoneIndex].Sign[1];
Quat.Z = Map[Controller->Bonemap[BoneIndex].XYZ[2]] * Controller->Bonemap[BoneIndex].Sign[2];
break;
}
case ENeuronSkeletonEnum::VE_UE4: // Map to UE4 world coordinate system
{
float Y = Quat.Y;
float Z = Quat.Z;
Quat.Y = Z;
Quat.Z = Y;
break;
}
case ENeuronSkeletonEnum::VE_None: // Map to nothing, use BVH rotation as it is
default:
{
// Nothing to do, Quaternion is already BVH
break;
}
}
// Convert to Rotator
Rotation = Quat.Rotator();
// Add additional rotation
Rotation.Yaw += AdditionalRotation.Yaw;
Rotation.Pitch += AdditionalRotation.Pitch;
Rotation.Roll += AdditionalRotation.Roll;
Rotation.Normalize();
return true;
}
FString UKismetStringLibrary::Conv_RotatorToString(FRotator InRot)
{
return InRot.ToString();
}
FRotator UKismetMathLibrary::NormalizedDeltaRotator(FRotator A, FRotator B)
{
FRotator Delta = A - B;
Delta.Normalize();
return Delta;
}
FVector UKismetMathLibrary::LessLess_VectorRotator(FVector A, FRotator B)
{
return B.UnrotateVector(A);
}
bool UMovementComponent::K2_MoveUpdatedComponent(FVector Delta, FRotator NewRotation, FHitResult& OutHit, bool bSweep, bool bTeleport)
{
return SafeMoveUpdatedComponent(Delta, NewRotation.Quaternion(), bSweep, OutHit, TeleportFlagToEnum(bTeleport));
}
void APlayerCameraManager::UpdateViewTarget(FTViewTarget& OutVT, float DeltaTime)
{
// Don't update outgoing viewtarget during an interpolation
if ((PendingViewTarget.Target != NULL) && BlendParams.bLockOutgoing && OutVT.Equal(ViewTarget))
{
return;
}
// store previous POV, in case we need it later
FMinimalViewInfo OrigPOV = OutVT.POV;
//@TODO: CAMERA: Should probably reset the view target POV fully here
OutVT.POV.FOV = DefaultFOV;
OutVT.POV.OrthoWidth = DefaultOrthoWidth;
OutVT.POV.bConstrainAspectRatio = false;
OutVT.POV.bUseFieldOfViewForLOD = true;
OutVT.POV.ProjectionMode = bIsOrthographic ? ECameraProjectionMode::Orthographic : ECameraProjectionMode::Perspective;
OutVT.POV.PostProcessSettings.SetBaseValues();
OutVT.POV.PostProcessBlendWeight = 1.0f;
bool bDoNotApplyModifiers = false;
if (ACameraActor* CamActor = Cast<ACameraActor>(OutVT.Target))
{
// Viewing through a camera actor.
CamActor->GetCameraComponent()->GetCameraView(DeltaTime, OutVT.POV);
}
else
{
static const FName NAME_Fixed = FName(TEXT("Fixed"));
static const FName NAME_ThirdPerson = FName(TEXT("ThirdPerson"));
static const FName NAME_FreeCam = FName(TEXT("FreeCam"));
static const FName NAME_FreeCam_Default = FName(TEXT("FreeCam_Default"));
static const FName NAME_FirstPerson = FName(TEXT("FirstPerson"));
if (CameraStyle == NAME_Fixed)
{
// do not update, keep previous camera position by restoring
// saved POV, in case CalcCamera changes it but still returns false
OutVT.POV = OrigPOV;
// don't apply modifiers when using this debug camera mode
bDoNotApplyModifiers = true;
}
else if (CameraStyle == NAME_ThirdPerson || CameraStyle == NAME_FreeCam || CameraStyle == NAME_FreeCam_Default)
{
// Simple third person view implementation
FVector Loc = OutVT.Target->GetActorLocation();
FRotator Rotator = OutVT.Target->GetActorRotation();
if (OutVT.Target == PCOwner)
{
Loc = PCOwner->GetFocalLocation();
}
// Take into account Mesh Translation so it takes into account the PostProcessing we do there.
// @fixme, can crash in certain BP cases where default mesh is null
// APawn* TPawn = Cast<APawn>(OutVT.Target);
// if ((TPawn != NULL) && (TPawn->Mesh != NULL))
// {
// Loc += FQuatRotationMatrix(OutVT.Target->GetActorQuat()).TransformVector(TPawn->Mesh->RelativeLocation - GetDefault<APawn>(TPawn->GetClass())->Mesh->RelativeLocation);
// }
//OutVT.Target.GetActorEyesViewPoint(Loc, Rot);
if( CameraStyle == NAME_FreeCam || CameraStyle == NAME_FreeCam_Default )
{
Rotator = PCOwner->GetControlRotation();
}
FVector Pos = Loc + FRotationMatrix(Rotator).TransformVector(FreeCamOffset) - Rotator.Vector() * FreeCamDistance;
FCollisionQueryParams BoxParams(NAME_FreeCam, false, this);
BoxParams.AddIgnoredActor(OutVT.Target);
FHitResult Result;
GetWorld()->SweepSingleByChannel(Result, Loc, Pos, FQuat::Identity, ECC_Camera, FCollisionShape::MakeBox(FVector(12.f)), BoxParams);
OutVT.POV.Location = !Result.bBlockingHit ? Pos : Result.Location;
OutVT.POV.Rotation = Rotator;
// don't apply modifiers when using this debug camera mode
bDoNotApplyModifiers = true;
}
else if (CameraStyle == NAME_FirstPerson)
{
// Simple first person, view through viewtarget's 'eyes'
OutVT.Target->GetActorEyesViewPoint(OutVT.POV.Location, OutVT.POV.Rotation);
// don't apply modifiers when using this debug camera mode
bDoNotApplyModifiers = true;
}
else
{
UpdateViewTargetInternal(OutVT, DeltaTime);
}
}
if (!bDoNotApplyModifiers || bAlwaysApplyModifiers)
{
// Apply camera modifiers at the end (view shakes for example)
ApplyCameraModifiers(DeltaTime, OutVT.POV);
}
if (bFollowHmdOrientation)
{
if (GEngine->HMDDevice.IsValid() && GEngine->HMDDevice->IsHeadTrackingAllowed())
{
GEngine->HMDDevice->UpdatePlayerCameraRotation(this, OutVT.POV);
}
}
// Synchronize the actor with the view target results
SetActorLocationAndRotation(OutVT.POV.Location, OutVT.POV.Rotation, false);
UpdateCameraLensEffects(OutVT);
}
bool UKismetMathLibrary::NotEqual_RotatorRotator(FRotator A, FRotator B, float ErrorTolerance)
{
return !A.Equals(B, ErrorTolerance);
}
void USpringArmComponent::UpdateDesiredArmLocation(bool bDoTrace, bool bDoLocationLag, bool bDoRotationLag, float DeltaTime)
{
FRotator DesiredRot = GetComponentRotation();
// If inheriting rotation, check options for which components to inherit
if(!bAbsoluteRotation)
{
if(!bInheritPitch)
{
DesiredRot.Pitch = RelativeRotation.Pitch;
}
if (!bInheritYaw)
{
DesiredRot.Yaw = RelativeRotation.Yaw;
}
if (!bInheritRoll)
{
DesiredRot.Roll = RelativeRotation.Roll;
}
}
// Apply 'lag' to rotation if desired
if(bDoRotationLag)
{
DesiredRot = FMath::RInterpTo(PreviousDesiredRot, DesiredRot, DeltaTime, CameraRotationLagSpeed);
}
PreviousDesiredRot = DesiredRot;
// Get the spring arm 'origin', the target we want to look at
FVector ArmOrigin = GetComponentLocation() + TargetOffset;
// We lag the target, not the actuall camera position, so rotating the camera around does not hav lag
FVector DesiredLoc = ArmOrigin;
if (bDoLocationLag)
{
DesiredLoc = FMath::VInterpTo(PreviousDesiredLoc, DesiredLoc, DeltaTime, CameraLagSpeed);
}
PreviousDesiredLoc = DesiredLoc;
// Now offset camera position back along our rotation
DesiredLoc -= DesiredRot.Vector() * TargetArmLength;
// Add socket offset in local space
DesiredLoc += FRotationMatrix(DesiredRot).TransformVector(SocketOffset);
// Do a sweep to ensure we are not penetrating the world
FVector ResultLoc;
if (bDoTrace && (TargetArmLength != 0.0f))
{
static FName TraceTagName(TEXT("SpringArm"));
FCollisionQueryParams QueryParams(TraceTagName, false, GetOwner());
FHitResult Result;
GetWorld()->SweepSingle(Result, ArmOrigin, DesiredLoc, FQuat::Identity, ProbeChannel, FCollisionShape::MakeSphere(ProbeSize), QueryParams);
ResultLoc = BlendLocations(DesiredLoc, Result.Location, Result.bBlockingHit, DeltaTime);
}
else
{
ResultLoc = DesiredLoc;
}
// Form a transform for new world transform for camera
FTransform WorldCamTM(DesiredRot, ResultLoc);
// Convert to relative to component
FTransform RelCamTM = WorldCamTM.GetRelativeTransform(ComponentToWorld);
// Update socket location/rotation
RelativeSocketLocation = RelCamTM.GetLocation();
RelativeSocketRotation = RelCamTM.GetRotation();
UpdateChildTransforms();
}
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;
}
}
}
// Thow out item with index
void UInventory::ThrowOutIndex(int32 ItemIndex)
{
// Inside the list of items
if (Items.IsValidIndex(ItemIndex) && ThePlayer && ThePlayer->IsAnimState(EAnimState::Idle_Run))
{
// Check if current weapon, can't throw out weapon that is equiped
if (Items[ItemIndex].Archetype && ThePlayer->TheWeapon
&& ThePlayer->TheWeapon->GetClass() == Items[ItemIndex].Archetype.GetDefaultObject()->GetClass())
{
return;
}
UWorld* const World = ThePlayer->GetWorld();
if (World && Items[ItemIndex].Archetype && Items[ItemIndex].Archetype->GetDefaultObject<AItem>())
{
// Get Player Rotation
FRotator rot = ThePlayer->GetActorRotation();
FVector spawnLoc = rot.Vector() * 200 + ThePlayer->FirstPersonCameraComponent->GetComponentLocation()+ FVector(0, 0, -50);
AItemPickup* newPickup;
AItem* newItem=Items[ItemIndex].Archetype->GetDefaultObject<AItem>();
// Spawn Item Pickup archtype
if (newItem && newItem->ItemPickupArchetype)
newPickup = World->SpawnActor<AItemPickup>(newItem->ItemPickupArchetype, spawnLoc, rot);
// Spawn Default pickup
else newPickup = World->SpawnActor<AItemPickup>(AItemPickup::StaticClass(), spawnLoc, rot);
if (newPickup)
{
newPickup->SetReplicates(true);
if (newItem)
{
newItem->BP_ItemDroped(newPickup);
newPickup->Item = newItem->GetClass();
if (newItem->PickupMesh)
{
newPickup->Mesh->SetStaticMesh(newItem->PickupMesh);
}
else if (newItem->PickupSkelMesh)
{
newPickup->SkeletalMesh->SetSkeletalMesh(newItem->PickupSkelMesh);
}
}
newPickup->bAutoPickup = true;
if (Cast<AWeapon>(newItem))
{
newPickup->bOverideItemData = true;
newPickup->OverideItemData = Items[ItemIndex];
}
if (Items[ItemIndex].ItemCount > 1)
{
Items[ItemIndex].ItemCount--;
}
else RemoveItemIndex(ItemIndex);
newPickup->ActivatePickupPhysics();
if (newPickup->Mesh && newPickup->Mesh->IsSimulatingPhysics())
{
newPickup->Mesh->AddImpulse(rot.Vector() * 12000, NAME_None, true);
}
if (newPickup->SkeletalMesh && newPickup->SkeletalMesh->IsSimulatingPhysics())
{
newPickup->SkeletalMesh->AddForce(rot.Vector() * 12000, NAME_None, true);
}
UpdateInfo();
}
}
}
}
static void ConvertRuneAnimations(UMeshAnimation &Anim, const TArray<RJoint> &Bones,
const TArray<FRSkelAnimSeq> &Seqs)
{
guard(ConvertRuneAnimations);
int i, j;
int numBones = Bones.Num();
// create RefBones
Anim.RefBones.Empty(Bones.Num());
for (i = 0; i < Bones.Num(); i++)
{
const RJoint &SB = Bones[i];
FNamedBone *B = new(Anim.RefBones) FNamedBone;
B->Name = SB.name;
B->Flags = 0;
B->ParentIndex = SB.parent;
}
// create AnimSeqs
Anim.AnimSeqs.Empty(Seqs.Num());
Anim.Moves.Empty(Seqs.Num());
for (i = 0; i < Seqs.Num(); i++)
{
// create FMeshAnimSeq
const FRSkelAnimSeq &SS = Seqs[i];
FMeshAnimSeq *S = new(Anim.AnimSeqs) FMeshAnimSeq;
S->Name = SS.Name;
CopyArray(S->Groups, SS.Groups);
S->StartFrame = 0;
S->NumFrames = SS.NumFrames;
S->Rate = SS.Rate;
//?? S->Notifys
// create MotionChunk
MotionChunk *M = new(Anim.Moves) MotionChunk;
M->TrackTime = SS.NumFrames;
// dummy bone remap
M->AnimTracks.Empty(numBones);
// convert animation data
const byte *data = &SS.animdata[0];
for (j = 0; j < numBones; j++)
{
// prepare AnalogTrack
AnalogTrack *A = new(M->AnimTracks) AnalogTrack;
A->KeyQuat.Empty(SS.NumFrames);
A->KeyPos.Empty(SS.NumFrames);
A->KeyTime.Empty(SS.NumFrames);
}
for (int frame = 0; frame < SS.NumFrames; frame++)
{
for (int joint = 0; joint < numBones; joint++)
{
AnalogTrack &A = M->AnimTracks[joint];
FVector pos, scale;
pos.Set(0, 0, 0);
scale.Set(1, 1, 1);
FRotator rot;
rot.Set(0, 0, 0);
byte f = *data++;
int16 d;
#define GET d = data[0] + (data[1] << 8); data += 2;
#define GETF(v) { GET; v = (float)d / 256.0f; }
#define GETI(v) { GET; v = d; }
// decode position
if (f & 1) GETF(pos.X);
if (f & 2) GETF(pos.Y);
if (f & 4) GETF(pos.Z);
// decode scale
if (f & 8) { GETF(scale.X); GETF(scale.Z); }
if (f & 0x10) GETF(scale.Y);
// decode rotation
if (f & 0x20) GETI(rot.Pitch);
if (f & 0x40) GETI(rot.Yaw);
if (f & 0x80) GETI(rot.Roll);
#undef GET
#undef GETF
#undef GETI
A.KeyQuat.Add(EulerToQuat(rot));
A.KeyPos.Add(pos);
//?? notify about scale!=(1,1,1)
}
}
assert(data == &SS.animdata[0] + SS.animdata.Num());
}
unguard;
}
void AGameplayDebuggingHUDComponent::DrawEQSData(APlayerController* PC, class UGameplayDebuggingComponent *DebugComponent)
{
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST) && WITH_EQS
PrintString(DefaultContext, TEXT("\n{green}EQS {white}[Use + key to switch query]\n"));
if (DebugComponent->EQSLocalData.Num() == 0)
{
return;
}
const int32 EQSIndex = DebugComponent->EQSLocalData.Num() > 0 ? FMath::Clamp(DebugComponent->CurrentEQSIndex, 0, DebugComponent->EQSLocalData.Num() - 1) : INDEX_NONE;
if (!DebugComponent->EQSLocalData.IsValidIndex(EQSIndex))
{
return;
}
{
int32 Index = 0;
PrintString(DefaultContext, TEXT("{white}Queries: "));
for (auto CurrentQuery : DebugComponent->EQSLocalData)
{
if (EQSIndex == Index)
{
PrintString(DefaultContext, FString::Printf(TEXT("{green}%s, "), *CurrentQuery.Name));
}
else
{
PrintString(DefaultContext, FString::Printf(TEXT("{yellow}%s, "), *CurrentQuery.Name));
}
Index++;
}
PrintString(DefaultContext, TEXT("\n"));
}
auto& CurrentLocalData = DebugComponent->EQSLocalData[EQSIndex];
/** find and draw item selection */
int32 BestItemIndex = INDEX_NONE;
{
APlayerController* const MyPC = Cast<APlayerController>(PlayerOwner);
FVector CamLocation;
FVector FireDir;
if (!MyPC->GetSpectatorPawn())
{
FRotator CamRotation;
MyPC->GetPlayerViewPoint(CamLocation, CamRotation);
FireDir = CamRotation.Vector();
}
else
{
FireDir = DefaultContext.Canvas->SceneView->GetViewDirection();
CamLocation = DefaultContext.Canvas->SceneView->ViewMatrices.ViewOrigin;
}
float bestAim = 0;
for (int32 Index = 0; Index < CurrentLocalData.RenderDebugHelpers.Num(); ++Index)
{
auto& CurrentItem = CurrentLocalData.RenderDebugHelpers[Index];
const FVector AimDir = CurrentItem.Location - CamLocation;
float FireDist = AimDir.SizeSquared();
FireDist = FMath::Sqrt(FireDist);
float newAim = FireDir | AimDir;
newAim = newAim / FireDist;
if (newAim > bestAim)
{
BestItemIndex = Index;
bestAim = newAim;
}
}
if (BestItemIndex != INDEX_NONE)
{
DrawDebugSphere(World, CurrentLocalData.RenderDebugHelpers[BestItemIndex].Location, CurrentLocalData.RenderDebugHelpers[BestItemIndex].Radius, 8, FColor::Red, false);
int32 FailedTestIndex = CurrentLocalData.RenderDebugHelpers[BestItemIndex].FailedTestIndex;
if (FailedTestIndex != INDEX_NONE)
{
PrintString(DefaultContext, FString::Printf(TEXT("{red}Selected item failed with test %d: {yellow}%s {LightBlue}(%s)\n")
, FailedTestIndex
, *CurrentLocalData.Tests[FailedTestIndex].ShortName
, *CurrentLocalData.Tests[FailedTestIndex].Detailed
));
PrintString(DefaultContext, FString::Printf(TEXT("{white}'%s' with score %3.3f\n\n"), *CurrentLocalData.RenderDebugHelpers[BestItemIndex].AdditionalInformation, CurrentLocalData.RenderDebugHelpers[BestItemIndex].FailedScore));
}
}
}
PrintString(DefaultContext, FString::Printf(TEXT("{white}Timestamp: {yellow}%.3f (%.2fs ago)\n")
, CurrentLocalData.Timestamp, PC->GetWorld()->GetTimeSeconds() - CurrentLocalData.Timestamp
));
PrintString(DefaultContext, FString::Printf(TEXT("{white}Query ID: {yellow}%d\n")
, CurrentLocalData.Id
));
PrintString(DefaultContext, FString::Printf(TEXT("{white}Query contains %d options: "), CurrentLocalData.Options.Num()));
for (int32 OptionIndex = 0; OptionIndex < CurrentLocalData.Options.Num(); ++OptionIndex)
{
if (OptionIndex == CurrentLocalData.UsedOption)
{
PrintString(DefaultContext, FString::Printf(TEXT("{green}%s, "), *CurrentLocalData.Options[OptionIndex]));
}
else
{
PrintString(DefaultContext, FString::Printf(TEXT("{yellow}%s, "), *CurrentLocalData.Options[OptionIndex]));
}
}
PrintString(DefaultContext, TEXT("\n"));
const float RowHeight = 20.0f;
const int32 NumTests = CurrentLocalData.Tests.Num();
if (CurrentLocalData.NumValidItems > 0 && GetDebuggingReplicator()->EnableEQSOnHUD )
{
// draw test weights for best X items
const int32 NumItems = CurrentLocalData.Items.Num();
FCanvasTileItem TileItem(FVector2D(0, 0), GWhiteTexture, FVector2D(Canvas->SizeX, RowHeight), FLinearColor::Black);
FLinearColor ColorOdd(0, 0, 0, 0.6f);
FLinearColor ColorEven(0, 0, 0.4f, 0.4f);
TileItem.BlendMode = SE_BLEND_Translucent;
// table header
{
DefaultContext.CursorY += RowHeight;
const float HeaderY = DefaultContext.CursorY + 3.0f;
TileItem.SetColor(ColorOdd);
DrawItem(DefaultContext, TileItem, 0, DefaultContext.CursorY);
float HeaderX = DefaultContext.CursorX;
PrintString(DefaultContext, FColor::Yellow, FString::Printf(TEXT("Num items: %d"), CurrentLocalData.NumValidItems), HeaderX, HeaderY);
HeaderX += ItemDescriptionWidth;
PrintString(DefaultContext, FColor::White, TEXT("Score"), HeaderX, HeaderY);
HeaderX += ItemScoreWidth;
for (int32 TestIdx = 0; TestIdx < NumTests; TestIdx++)
{
PrintString(DefaultContext, FColor::White, FString::Printf(TEXT("Test %d"), TestIdx), HeaderX, HeaderY);
HeaderX += TestScoreWidth;
}
DefaultContext.CursorY += RowHeight;
}
// valid items
for (int32 Idx = 0; Idx < NumItems; Idx++)
{
TileItem.SetColor((Idx % 2) ? ColorOdd : ColorEven);
DrawItem(DefaultContext, TileItem, 0, DefaultContext.CursorY);
DrawEQSItemDetails(Idx, DebugComponent);
DefaultContext.CursorY += RowHeight;
}
DefaultContext.CursorY += RowHeight;
}
// test description
PrintString(DefaultContext, TEXT("All tests from used option:\n"));
for (int32 TestIdx = 0; TestIdx < NumTests; TestIdx++)
{
FString TestDesc = FString::Printf(TEXT("{white}Test %d = {yellow}%s {LightBlue}(%s)\n"), TestIdx,
*CurrentLocalData.Tests[TestIdx].ShortName,
*CurrentLocalData.Tests[TestIdx].Detailed);
PrintString(DefaultContext, TestDesc);
}
#endif //!(UE_BUILD_SHIPPING || UE_BUILD_TEST)
}
void AGameplayDebuggingHUDComponent::DrawMenu(const float X, const float Y, class UGameplayDebuggingComponent* DebugComponent)
{
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
const float OldX = DefaultContext.CursorX;
const float OldY = DefaultContext.CursorY;
UGameplayDebuggingControllerComponent* GDC = GetDebuggingReplicator()->FindComponentByClass<UGameplayDebuggingControllerComponent>();
if (DefaultContext.Canvas != NULL)
{
TArray<FDebugCategoryView> Categories;
GetKeyboardDesc(Categories);
UFont* OldFont = DefaultContext.Font;
DefaultContext.Font = GEngine->GetMediumFont();
TArray<float> CategoriesWidth;
CategoriesWidth.AddZeroed(Categories.Num());
float TotalWidth = 0.0f, MaxHeight = 0.0f;
FString ActivationKeyDisplayName = TEXT("'");
FString ActivationKeyName = TEXT("Apostrophe");
APlayerController* const MyPC = Cast<APlayerController>(PlayerOwner);
if (GDC)
{
ActivationKeyDisplayName = GDC->GetActivationKey().Key.GetDisplayName().ToString();
ActivationKeyName = GDC->GetActivationKey().Key.GetFName().ToString();
}
const FString KeyDesc = ActivationKeyName != ActivationKeyDisplayName ? FString::Printf(TEXT("(%s key)"), *ActivationKeyName) : TEXT("");
FString HeaderDesc = FString::Printf(TEXT("Tap %s %s to close, use Numpad numbers to toggle categories"), *ActivationKeyDisplayName, *KeyDesc);
float HeaderWidth = 0.0f;
CalulateStringSize(DefaultContext, DefaultContext.Font, HeaderDesc, HeaderWidth, MaxHeight);
for (int32 i = 0; i < Categories.Num(); i++)
{
Categories[i].Desc = FString::Printf(TEXT("%d:%s "), i, *Categories[i].Desc);
float StrHeight = 0.0f;
CalulateStringSize(DefaultContext, DefaultContext.Font, Categories[i].Desc, CategoriesWidth[i], StrHeight);
TotalWidth += CategoriesWidth[i];
MaxHeight = FMath::Max(MaxHeight, StrHeight);
}
{
static FString KeyShortcut = GDC->DebugCameraBind.GetInputText().ToString();
const int32 DebugCameraIndex = Categories.Add(FDebugCategoryView());
CategoriesWidth.AddZeroed(1);
Categories[DebugCameraIndex].Desc = FString::Printf(TEXT(" %s[%s]: %s "), GDC && GDC->GetDebugCameraController().IsValid() ? TEXT("{Green}") : TEXT("{White}"), *KeyShortcut, TEXT("Debug Camera"));
float StrHeight = 0.0f;
CalulateStringSize(DefaultContext, DefaultContext.Font, Categories[DebugCameraIndex].Desc, CategoriesWidth[DebugCameraIndex], StrHeight);
TotalWidth += CategoriesWidth[DebugCameraIndex];
MaxHeight = FMath::Max(MaxHeight, StrHeight);
}
{
static FString KeyShortcut = GDC->OnScreenDebugMessagesBind.GetInputText().ToString();
const int32 DebugCameraIndex = Categories.Add(FDebugCategoryView());
CategoriesWidth.AddZeroed(1);
Categories[DebugCameraIndex].Desc = FString::Printf(TEXT(" %s[%s]: %s "), GEngine && GEngine->bEnableOnScreenDebugMessages ? TEXT("{Green}") : TEXT("{White}"), *KeyShortcut, TEXT("DebugMessages"));
float StrHeight = 0.0f;
CalulateStringSize(DefaultContext, DefaultContext.Font, Categories[DebugCameraIndex].Desc, CategoriesWidth[DebugCameraIndex], StrHeight);
TotalWidth += CategoriesWidth[DebugCameraIndex];
MaxHeight = FMath::Max(MaxHeight, StrHeight);
}
{
static FString KeyShortcut = GDC->GameHUDBind.GetInputText().ToString();
const AHUD* GameHUD = MyPC ? MyPC->GetHUD() : NULL;
const int32 DebugCameraIndex = Categories.Add(FDebugCategoryView());
CategoriesWidth.AddZeroed(1);
Categories[DebugCameraIndex].Desc = FString::Printf(TEXT(" %s[%s]: %s "), GameHUD && GameHUD->bShowHUD ? TEXT("{Green}") : TEXT("{White}"), *KeyShortcut, TEXT("GameHUD"));
float StrHeight = 0.0f;
CalulateStringSize(DefaultContext, DefaultContext.Font, Categories[DebugCameraIndex].Desc, CategoriesWidth[DebugCameraIndex], StrHeight);
TotalWidth += CategoriesWidth[DebugCameraIndex];
MaxHeight = FMath::Max(MaxHeight, StrHeight);
}
TotalWidth = FMath::Max(TotalWidth, HeaderWidth);
FCanvasTileItem TileItem(FVector2D(10, 10), GWhiteTexture, FVector2D(TotalWidth + 20, MaxHeight + 20), FColor(0, 0, 0, 20));
TileItem.BlendMode = SE_BLEND_Translucent;
DrawItem(DefaultContext, TileItem, MenuStartX, MenuStartY);
PrintString(DefaultContext, FColorList::LightBlue, HeaderDesc, MenuStartX + 2.f, MenuStartY + 2.f);
float XPos = MenuStartX + 20.f;
for (int32 i = 0; i < Categories.Num(); i++)
{
const bool bIsActive = GameplayDebuggerSettings(GetDebuggingReplicator()).CheckFlag(Categories[i].View) ? true : false;
const bool bIsDisabled = Categories[i].View == EAIDebugDrawDataView::NavMesh ? false : (DebugComponent && DebugComponent->GetSelectedActor() ? false: true);
PrintString(DefaultContext, bIsDisabled ? (bIsActive ? FColorList::DarkGreen : FColorList::LightGrey) : (bIsActive ? FColorList::Green : FColorList::White), Categories[i].Desc, XPos, MenuStartY + MaxHeight + 2.f);
XPos += CategoriesWidth[i];
}
DefaultContext.Font = OldFont;
}
if ((!DebugComponent || !DebugComponent->GetSelectedActor()) && GetWorld()->GetNetMode() == NM_Client)
{
PrintString(DefaultContext, "\n{red}No Pawn selected - waiting for data to replicate from server. {green}Press and hold ' to select Pawn \n");
}
if (GDC && GDC->GetDebugCameraController().IsValid())
{
ADebugCameraController* DebugCamController = GDC->GetDebugCameraController().Get();
if (DebugCamController != NULL)
{
FVector const CamLoc = DebugCamController->PlayerCameraManager->GetCameraLocation();
FRotator const CamRot = DebugCamController->PlayerCameraManager->GetCameraRotation();
FString HitString;
FCollisionQueryParams TraceParams(NAME_None, true, this);
FHitResult Hit;
bool bHit = GetWorld()->LineTraceSingleByChannel(Hit, CamLoc, CamRot.Vector() * 100000.f + CamLoc, ECC_Pawn, TraceParams);
if (bHit && Hit.GetActor() != nullptr)
{
HitString = FString::Printf(TEXT("{white}Under cursor: {yellow}'%s'"), *Hit.GetActor()->GetName());
DrawDebugLine(GetWorld(), Hit.Location, Hit.Location + Hit.Normal*30.f, FColor::White);
}
else
{
HitString = FString::Printf(TEXT("Not actor under cursor"));
}
PrintString(DefaultContext, FColor::White, HitString, MenuStartX, MenuStartY + 40);
}
}
DefaultContext.CursorX = OldX;
DefaultContext.CursorY = OldY;
#endif //!(UE_BUILD_SHIPPING || UE_BUILD_TEST)
}
void UPhysicsConstraintComponent::SetAngularOrientationTarget( const FRotator& InPosTarget )
{
ConstraintInstance.SetAngularOrientationTarget(InPosTarget.Quaternion());
}
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;
}
void AWizardsCharacter::OnFire()
{
if (!mySpellBook.IsValidIndex(0)) {
UE_LOG(LogTemp, Warning, TEXT("Spell Gathering Needed!"));
newCharactersSpells();
}
if (Mana > mySpellBook[currSpell].spellCost) {
Mana -= mySpellBook[currSpell].spellCost;
// try and fire a projectile
if (mySpellBook[currSpell].spellType == 0)
{
const FRotator SpawnRotation = GetControlRotation();
const FVector SpawnLocation = GetActorLocation() + SpawnRotation.RotateVector(GunOffset);
UWorld* const World = GetWorld();
if (World)
{
// spawn the projectile at the muzzle
/*UParticleSystem* projParticle = particleList[mySpellBook[currSpell].spellEffect + mySpellBook[currSpell].spellType * 5];
UParticleSystem* blastParticle = particleList[mySpellBook[currSpell].spellEffect + 5];
AWizardsProjectile* wizardsSpell = World->SpawnActor<AWizardsProjectile>(ProjectileClass, SpawnLocation, SpawnRotation);// , myparams);
wizardsSpell->SpellCreation(&mySpellBook[currSpell], projParticle, blastParticle, this);*/
if (Role < ROLE_Authority)
{
ServerFireProjectile(mySpellBook[currSpell], SpawnRotation, SpawnLocation);//mySpellBook[currSpell]);
}
else {
ClientFireProjectile(mySpellBook[currSpell], SpawnRotation, SpawnLocation);
}
}
}
else if (mySpellBook[currSpell].spellType == 1) {
const FRotator SpawnRotation = FRotator(0.0);//GetControlRotation();
// MuzzleOffset is in camera space, so transform it to world space before offsetting from the character location to find the final muzzle position
const FVector SpawnLocation = FVector(0.0);//GetActorLocation() + SpawnRotation.RotateVector(GunOffset);
UWorld* const World = GetWorld();
if (World)
{
// spawn the projectile at the muzzle
/*UParticleSystem* blastParticle = particleList[mySpellBook[currSpell].spellEffect + mySpellBook[currSpell].spellType * 5];
AWizardsBlast* wizardsSpell = World->SpawnActor<AWizardsBlast>(BlastClass, SpawnLocation, SpawnRotation);// , myparams);
wizardsSpell->SpellCreation(blastParticle, mySpellBook[currSpell].spellSize, mySpellBook[currSpell].spellDamage, this);
wizardsSpell->AttachRootComponentTo(GetCapsuleComponent());//Probably useful for Blasts, Rays, and Conical attacks*/
if (Role < ROLE_Authority)
{
ServerFireProjectile(mySpellBook[currSpell], SpawnRotation, SpawnLocation);
}
else {
ClientFireProjectile(mySpellBook[currSpell], SpawnRotation, SpawnLocation);
}
}
}
else if (mySpellBook[currSpell].spellType == 2) {
const FRotator SpawnRotation = FRotator(0.0);//GetControlRotation();
// MuzzleOffset is in camera space, so transform it to world space before offsetting from the character location to find the final muzzle position
const FVector SpawnLocation = FVector(0.0);//GetActorLocation() + SpawnRotation.RotateVector(GunOffset);
UWorld* const World = GetWorld();
if (World)
{
// spawn the projectile at the muzzle
/*UParticleSystem* coneParticle = particleList[mySpellBook[currSpell].spellEffect + mySpellBook[currSpell].spellType * 5];
AWizardsCone* wizardsCone = World->SpawnActor<AWizardsCone>(ConeClass, SpawnLocation, SpawnRotation);// , myparams);
wizardsCone->SpellCreation(coneParticle, mySpellBook[currSpell].spellSize, mySpellBook[currSpell].spellDamage, this);
wizardsCone->AttachRootComponentTo(GetCapsuleComponent());//Probably useful for Blasts, Rays, and Conical attacks
activeAttack = Cast<AActor>(wizardsCone);*/
if (Role < ROLE_Authority)
{
ServerFireProjectile(mySpellBook[currSpell], SpawnRotation, SpawnLocation);
}
else {
ClientFireProjectile(mySpellBook[currSpell], SpawnRotation, SpawnLocation);
}
}
}
// God this sound is so annoying
/*if (FireSound != NULL)
{
UGameplayStatics::PlaySoundAtLocation(this, FireSound, GetActorLocation());
}*/
// try and play a firing animation if specified
if (FireAnimation != NULL)
{
// Get the animation object for the arms mesh
UAnimInstance* AnimInstance = Mesh1P->GetAnimInstance();
if (AnimInstance != NULL)
{
AnimInstance->Montage_Play(FireAnimation, 1.f);
}
}
}
}
// Actual Melee Attack
void AWeapon::MeleeAttack()
{
BP_MeleeAttack();
if (Mesh1P && ThePlayer && ThePlayer->Controller)
{
FVector CamLoc;
FRotator CamRot;
ThePlayer->Controller->GetPlayerViewPoint(CamLoc, CamRot);
/// Get Camera Location and Rotation
FVector Camoffset = ThePlayer->FirstPersonCameraComponent->RelativeLocation;
FVector TraceStart = Camoffset + ThePlayer->GetActorLocation() - CamRot.Vector() * 20;
FVector TraceEnd = Camoffset + ThePlayer->GetActorLocation() + CamRot.Vector() * MeleeAttackDistance;
// Set trace values and perform trace to retrieve hit info
FCollisionQueryParams TraceParams(FName(TEXT("Melee Weapon Trace")), true, this);
TraceParams.bTraceAsyncScene = true;
TraceParams.bReturnPhysicalMaterial = true;
TraceParams.AddIgnoredActor(ThePlayer);
TraceParams.AddIgnoredActor(this);
FHitResult FHit(ForceInit);
GetWorld()->LineTraceSingleByChannel(FHit, TraceStart, TraceEnd, ECC_WorldStatic, TraceParams);
ARadeCharacter* EnemyPlayer = Cast<ARadeCharacter>(FHit.GetActor());
// Forward Hit Checking
if (EnemyPlayer)
{
if (EnemyPlayer)
{
// Hit Enemy
BP_HitEnemy(FHit);
// Apply Damage
UGameplayStatics::ApplyDamage(EnemyPlayer, MeleeAttackDamage, ThePlayer->Controller, Cast<AActor>(this), UDamageType::StaticClass());
}
}
else
{
// Right Hit Checking
FHitResult RHit(ForceInit);
FVector rightAngle = CamRot.Vector().RotateAngleAxis(MeleeAttackAngles, FVector::UpVector);
rightAngle = Camoffset + ThePlayer->GetActorLocation() + rightAngle * MeleeAttackDistance;
GetWorld()->LineTraceSingleByChannel(RHit, TraceStart, rightAngle, ECC_WorldStatic, TraceParams);
EnemyPlayer = Cast<ARadeCharacter>(RHit.GetActor());
if (EnemyPlayer)
{
BP_HitEnemy(RHit);
// Apply Damage
UGameplayStatics::ApplyDamage(EnemyPlayer, MeleeAttackDamage, ThePlayer->Controller, Cast<AActor>(this), UDamageType::StaticClass());
}
else
{
// Left Hit Checking
FHitResult LHit(ForceInit);
FVector leftAngle = CamRot.Vector().RotateAngleAxis(-MeleeAttackAngles, FVector::UpVector);
leftAngle = Camoffset + ThePlayer->GetActorLocation() + leftAngle * MeleeAttackDistance;
GetWorld()->LineTraceSingleByChannel(LHit, TraceStart, leftAngle, ECC_WorldStatic, TraceParams);
EnemyPlayer = Cast<ARadeCharacter>(LHit.GetActor());
if (EnemyPlayer)
{
BP_HitEnemy(LHit);
// Apply Damage
UGameplayStatics::ApplyDamage(EnemyPlayer, MeleeAttackDamage, ThePlayer->Controller, Cast<AActor>(this), UDamageType::StaticClass());
}
}
}
}
}
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 UCheatManager::BugItStringCreator( FVector ViewLocation, FRotator ViewRotation, FString& GoString, FString& LocString )
{
GoString = FString::Printf(TEXT("BugItGo %f %f %f %f %f %f"), ViewLocation.X, ViewLocation.Y, ViewLocation.Z, ViewRotation.Pitch, ViewRotation.Yaw, ViewRotation.Roll);
UE_LOG(LogCheatManager, Log, TEXT("%s"), *GoString);
LocString = FString::Printf(TEXT("?BugLoc=%s?BugRot=%s"), *ViewLocation.ToString(), *ViewRotation.ToString());
UE_LOG(LogCheatManager, Log, TEXT("%s"), *LocString);
}
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;
}
}
void UCheatManager::Summon( const FString& ClassName )
{
UE_LOG(LogCheatManager, Log, TEXT("Fabricate %s"), *ClassName );
bool bIsValidClassName = true;
FString FailureReason;
if ( ClassName.Contains(TEXT(" ")) )
{
FailureReason = FString::Printf(TEXT("ClassName contains a space."));
bIsValidClassName = false;
}
else if ( !FPackageName::IsShortPackageName(ClassName) )
{
if ( ClassName.Contains(TEXT(".")) )
{
FString PackageName;
FString ObjectName;
ClassName.Split(TEXT("."), &PackageName, &ObjectName);
const bool bIncludeReadOnlyRoots = true;
FText Reason;
if ( !FPackageName::IsValidLongPackageName(PackageName, bIncludeReadOnlyRoots, &Reason) )
{
FailureReason = Reason.ToString();
bIsValidClassName = false;
}
}
else
{
FailureReason = TEXT("Class names with a path must contain a dot. (i.e /Script/Engine.StaticMeshActor)");
bIsValidClassName = false;
}
}
bool bSpawnedActor = false;
if ( bIsValidClassName )
{
UClass* NewClass = NULL;
if ( FPackageName::IsShortPackageName(ClassName) )
{
NewClass = FindObject<UClass>(ANY_PACKAGE, *ClassName);
}
else
{
NewClass = FindObject<UClass>(NULL, *ClassName);
}
if( NewClass )
{
if ( NewClass->IsChildOf(AActor::StaticClass()) )
{
APlayerController* const MyPlayerController = GetOuterAPlayerController();
if(MyPlayerController)
{
FRotator const SpawnRot = MyPlayerController->GetControlRotation();
FVector SpawnLoc = MyPlayerController->GetFocalLocation();
SpawnLoc += 72.f * SpawnRot.Vector() + FVector(0.f, 0.f, 1.f) * 15.f;
FActorSpawnParameters SpawnInfo;
SpawnInfo.Instigator = MyPlayerController->Instigator;
AActor* Actor = GetWorld()->SpawnActor(NewClass, &SpawnLoc, &SpawnRot, SpawnInfo );
if ( Actor )
{
bSpawnedActor = true;
}
else
{
FailureReason = TEXT("SpawnActor failed.");
bSpawnedActor = false;
}
}
}
else
{
FailureReason = TEXT("Class is not derived from Actor.");
bSpawnedActor = false;
}
}
else
{
FailureReason = TEXT("Failed to find class.");
bSpawnedActor = false;
}
}
if ( !bSpawnedActor )
{
UE_LOG(LogCheatManager, Warning, TEXT("Failed to summon %s. Reason: %s"), *ClassName, *FailureReason);
}
}
void ADebugCameraHUD::PostRender()
{
Super::PostRender();
if (bShowHUD)
{
ADebugCameraController* DCC = Cast<ADebugCameraController>( PlayerOwner );
UFont* RenderFont = GEngine->GetSmallFont();
if( DCC != NULL )
{
FFontRenderInfo FontRenderInfo = Canvas->CreateFontRenderInfo(false, true);
Canvas->SetDrawColor(64, 64, 255, 255);
FString MyText = TEXT("Debug Camera");
float xl, yl;
Canvas->StrLen(RenderFont, MyText, xl, yl);
float X = Canvas->SizeX * 0.05f;
float Y = yl;//*1.67;
yl += 2*Y;
Canvas->DrawText(RenderFont, MyText, X, yl, 1.f, 1.f, FontRenderInfo);
Canvas->SetDrawColor(200, 200, 128, 255);
FVector const CamLoc = DCC->PlayerCameraManager->GetCameraLocation();
FRotator const CamRot = DCC->PlayerCameraManager->GetCameraRotation();
float const CamFOV = DCC->PlayerCameraManager->GetFOVAngle();
yl += Y;
FString const LocRotString = FString::Printf(TEXT("Loc=(%.1f, %.1f, %.1f) Rot=(%.1f, %.1f, %.1f)"), CamLoc.X, CamLoc.Y, CamLoc.Z, CamRot.Pitch, CamRot.Yaw, CamRot.Roll);
Canvas->DrawText(RenderFont, LocRotString, X, yl, 1.f, 1.f, FontRenderInfo);
yl += Y;
FString const FOVString = FString::Printf(TEXT("HFOV=%.1f"), CamFOV);
Canvas->DrawText(RenderFont, FOVString, X, yl, 1.f, 1.f, FontRenderInfo);
yl += Y;
FString const SpeedScaleString = FString::Printf(TEXT("SpeedScale=%.2fx"), DCC->SpeedScale);
Canvas->DrawText(RenderFont, SpeedScaleString, X, yl, 1.f, 1.f, FontRenderInfo);
yl += Y;
FString const SpeedString = FString::Printf(TEXT("MaxSpeed=%.1f"), DCC->GetSpectatorPawn() && DCC->GetSpectatorPawn()->GetMovementComponent() ? DCC->GetSpectatorPawn()->GetMovementComponent()->GetMaxSpeed() : 0.f);
Canvas->DrawText(RenderFont, SpeedString, X, yl, 1.f, 1.f, FontRenderInfo);
yl += Y;
//Canvas->DrawText(FString::Printf(TEXT("CamLoc:%s CamRot:%s"), *CamLoc.ToString(), *CamRot.ToString() ));
const TCHAR* CVarComplexName = TEXT("g.DebugCameraTraceComplex");
bool bTraceComplex = true;
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
bTraceComplex = CVarDebugCameraTraceComplex.GetValueOnGameThread() != 0;
#endif
FCollisionQueryParams TraceParams(NAME_None, bTraceComplex, this);
FHitResult Hit;
bool bHit = GetWorld()->LineTraceSingleByChannel(Hit, CamLoc, CamRot.Vector() * 100000.f + CamLoc, ECC_Pawn, TraceParams);
yl += Y;
Canvas->DrawText(RenderFont, FString::Printf(TEXT("Trace info (%s = %d):"), CVarComplexName, bTraceComplex ? 1 : 0), X, yl, 1.f, 1.f, FontRenderInfo);
if( bHit )
{
AActor* HitActor = Hit.GetActor();
yl += Y;
Canvas->DrawText(RenderFont, FString::Printf(TEXT("HitLoc:%s HitNorm:%s"), *Hit.Location.ToString(), *Hit.Normal.ToString() ), X, yl, 1.f, 1.f, FontRenderInfo);
yl += Y;
Canvas->DrawText(RenderFont, FString::Printf(TEXT("HitDist: %f"), Hit.Distance), X, yl, 1.f, 1.f, FontRenderInfo);
yl += Y;
Canvas->DrawText(RenderFont, FString::Printf(TEXT("HitActor: '%s'"), HitActor ? *HitActor->GetFName().ToString() : TEXT("<NULL>")), X, yl, 1.f, 1.f, FontRenderInfo);
yl += Y;
Canvas->DrawText(RenderFont, FString::Printf(TEXT("HitComponent: '%s'"), Hit.Component.Get() ? *Hit.Component.Get()->GetFName().ToString() : TEXT("<NULL>")), X, yl, 1.f, 1.f, FontRenderInfo);
yl += Y;
Canvas->DrawText(RenderFont, FString::Printf(TEXT("HitActor Class: '%s'"), HitActor && HitActor->GetClass() ? *HitActor->GetClass()->GetName() : TEXT("<Not Found>") ), X, yl, 1.f, 1.f, FontRenderInfo);
yl += Y;
Canvas->DrawText(RenderFont, FString::Printf(TEXT("HitActorPath: '%s'"), HitActor ? *HitActor->GetPathName() : TEXT("<Not Found>")), X, yl, 1.f, 1.f, FontRenderInfo);
yl += Y;
bool bFoundMaterial = false;
if ( Hit.Component != NULL )
{
bFoundMaterial = DisplayMaterials( X, yl, Y, Cast<UMeshComponent>(Hit.Component.Get()) );
}
else
{
TInlineComponentArray<UMeshComponent*> Components;
GetComponents(Components);
for ( int32 i=0; i<Components.Num(); i++ )
{
UMeshComponent* MeshComp = Components[i];
if ( MeshComp->IsRegistered() )
{
bFoundMaterial = bFoundMaterial || DisplayMaterials( X, yl, Y, MeshComp );
}
}
}
if ( bFoundMaterial == false )
{
yl += Y;
Canvas->DrawText(RenderFont, "Material: NULL", X + Y, yl, 1.f, 1.f, FontRenderInfo );
}
DrawDebugLine( GetWorld(), Hit.Location, Hit.Location+Hit.Normal*30.f, FColor::White );
}
else
{
yl += Y;
Canvas->DrawText( RenderFont, TEXT("No trace Hit"), X, yl, 1.f, 1.f, FontRenderInfo);
}
if ( DCC->bShowSelectedInfo && DCC->SelectedActor != NULL )
{
yl += Y;
Canvas->DrawText(RenderFont, FString::Printf(TEXT("Selected actor: '%s'"), *DCC->SelectedActor->GetFName().ToString()), X, yl, 1.f, 1.f, FontRenderInfo);
DisplayMaterials( X, yl, Y, Cast<UMeshComponent>(DCC->SelectedComponent) );
}
// controls display
yl += Y*15;
Canvas->SetDrawColor(64, 64, 255, 255);
Canvas->DrawText(RenderFont, TEXT("Controls"), X, yl, 1.f, 1.f, FontRenderInfo);
yl += Y;
Canvas->SetDrawColor(200, 200, 128, 255);
Canvas->DrawText(RenderFont, TEXT("FOV +/-: ,/. or DPad Up/Down"), X, yl, 1.f, 1.f, FontRenderInfo);
yl += Y;
Canvas->DrawText(RenderFont, TEXT("Speed +/-: MouseWheel or +/- or LB/RB"), X, yl, 1.f, 1.f, FontRenderInfo);
yl += Y;
Canvas->DrawText(RenderFont, TEXT("Freeze Rendering: F or YButton"), X, yl, 1.f, 1.f, FontRenderInfo);
yl += Y;
Canvas->DrawText(RenderFont, TEXT("Toggle Display: BackSpace or XButton"), X, yl, 1.f, 1.f, FontRenderInfo);
yl += Y;
}
}
}
void UCheatManager::TickCollisionDebug()
{
// If we are debugging capsule tracing
if(bDebugCapsuleSweep)
{
APlayerController* PC = GetOuterAPlayerController();
if(PC)
{
// Get view location to act as start point
FVector ViewLoc;
FRotator ViewRot;
PC->GetPlayerViewPoint(ViewLoc, ViewRot);
FVector ViewDir = ViewRot.Vector();
FVector End = ViewLoc + (DebugTraceDistance * ViewDir);
// Fill in params and do trace
static const FName TickCollisionDebugName(TEXT("TickCollisionDebug"));
FCollisionQueryParams CapsuleParams(TickCollisionDebugName, false, PC->GetPawn());
CapsuleParams.bTraceComplex = bDebugCapsuleTraceComplex;
if (bDebugCapsuleSweep)
{
// If we get a hit, draw the capsule
FHitResult Result;
bool bHit = GetWorld()->SweepSingle(Result, ViewLoc, End, FQuat::Identity, DebugTraceChannel, FCollisionShape::MakeCapsule(DebugCapsuleRadius, DebugCapsuleHalfHeight), CapsuleParams);
if(bHit)
{
AddCapsuleSweepDebugInfo(ViewLoc, End, Result.ImpactPoint, Result.Normal, Result.ImpactNormal, Result.Location, DebugCapsuleHalfHeight, DebugCapsuleRadius, false, (Result.bStartPenetrating && Result.bBlockingHit)? true: false);
UE_LOG(LogCollision, Log, TEXT("Collision component (%s) : Actor (%s)"), *GetNameSafe(Result.Component.Get()), *GetNameSafe(Result.GetActor()));
}
}
}
}
// draw
for (int32 TraceIdx=0; TraceIdx < DebugTraceInfoList.Num(); ++TraceIdx)
{
FDebugTraceInfo & TraceInfo = DebugTraceInfoList[TraceIdx];
DrawDebugDirectionalArrow(GetWorld(), TraceInfo.LineTraceStart, TraceInfo.LineTraceEnd, 10.f, FColor::White, SDPG_World);
// if it's current trace index, use highlight color
if (CurrentTraceIndex == TraceIdx)
{
if (TraceInfo.bInsideOfObject)
{
DrawDebugCapsule(GetWorld(), TraceInfo.HitLocation, TraceInfo.CapsuleHalfHeight, TraceInfo.CapsuleRadius, FQuat::Identity, FColor(255,100,64));
}
else
{
DrawDebugCapsule(GetWorld(), TraceInfo.HitLocation, TraceInfo.CapsuleHalfHeight, TraceInfo.CapsuleRadius, FQuat::Identity, FColor(255,200,128));
}
}
else
{
if (TraceInfo.bInsideOfObject)
{
DrawDebugCapsule(GetWorld(), TraceInfo.HitLocation, TraceInfo.CapsuleHalfHeight, TraceInfo.CapsuleRadius, FQuat::Identity, FColor(64,100,255));
}
else
{
DrawDebugCapsule(GetWorld(), TraceInfo.HitLocation, TraceInfo.CapsuleHalfHeight, TraceInfo.CapsuleRadius, FQuat::Identity, FColor(128,200,255));
}
}
DrawDebugDirectionalArrow(GetWorld(), TraceInfo.HitNormalStart, TraceInfo.HitNormalEnd, 5, FColor(255,64,64), SDPG_World);
DrawDebugDirectionalArrow(GetWorld(), TraceInfo.HitNormalStart, TraceInfo.HitImpactNormalEnd, 5, FColor(64,64,255), SDPG_World);
}
FLinearColor CurrentColor(255.f/255.f,96.f/255.f,96/255.f);
FLinearColor DeltaColor = (FLinearColor(1.0f, 1.0f, 1.0f, 1.0f) - CurrentColor)*0.1f;
int32 TotalCount=0;
if ( DebugTracePawnInfoList.Num() > 0 )
{
// the latest will draw very red-ish to whiter color as it gets older.
for (int32 TraceIdx=CurrentTracePawnIndex; TotalCount<10; TraceIdx=SAFE_TRACEINDEX_DECREASE(TraceIdx), CurrentColor+=DeltaColor, ++TotalCount)
{
FDebugTraceInfo & TraceInfo = DebugTracePawnInfoList[TraceIdx];
DrawDebugDirectionalArrow(GetWorld(), TraceInfo.LineTraceStart, TraceInfo.LineTraceEnd, 10.f, FColor(200,200,100), SDPG_World);
if (TraceInfo.bInsideOfObject)
{
DrawDebugCapsule(GetWorld(), TraceInfo.HitLocation, TraceInfo.CapsuleHalfHeight, TraceInfo.CapsuleRadius, FQuat::Identity, FColor(64, 64, 255));
}
else
{
DrawDebugCapsule(GetWorld(), TraceInfo.HitLocation, TraceInfo.CapsuleHalfHeight, TraceInfo.CapsuleRadius, FQuat::Identity, CurrentColor.Quantize());
}
DrawDebugDirectionalArrow(GetWorld(), TraceInfo.HitNormalStart, TraceInfo.HitNormalEnd, 5.f, FColor(255,64,64), SDPG_World);
}
}
}
FVector UKismetMathLibrary::GreaterGreater_VectorRotator(FVector A, FRotator B)
{
return B.RotateVector(A);
}
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;
}
FVector UKismetMathLibrary::Conv_RotatorToVector(FRotator InRot)
{
return InRot.Vector();
}
void ASCharacter::DropWeapon()
{
if (Role < ROLE_Authority)
{
ServerDropWeapon();
return;
}
if (CurrentWeapon)
{
FVector CamLoc;
FRotator CamRot;
if (Controller == nullptr)
{
return;
}
/* Find a location to drop the item, slightly in front of the player.
Perform ray trace to check for blocking objects or walls and to make sure we don't drop any item through the level mesh */
Controller->GetPlayerViewPoint(CamLoc, CamRot);
FVector SpawnLocation;
FRotator SpawnRotation = CamRot;
const FVector Direction = CamRot.Vector();
const FVector TraceStart = GetActorLocation();
const FVector TraceEnd = GetActorLocation() + (Direction * DropWeaponMaxDistance);
/* Setup the trace params, we are only interested in finding a valid drop position */
FCollisionQueryParams TraceParams;
TraceParams.bTraceComplex = false;
TraceParams.bReturnPhysicalMaterial = false;
TraceParams.AddIgnoredActor(this);
FHitResult Hit;
GetWorld()->LineTraceSingleByChannel(Hit, TraceStart, TraceEnd, ECC_WorldDynamic, TraceParams);
/* Find farthest valid spawn location */
if (Hit.bBlockingHit)
{
/* Slightly move away from impacted object */
SpawnLocation = Hit.ImpactPoint + (Hit.ImpactNormal * 20);
}
else
{
SpawnLocation = TraceEnd;
}
/* Spawn the "dropped" weapon */
FActorSpawnParameters SpawnInfo;
SpawnInfo.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
ASWeaponPickup* NewWeaponPickup = GetWorld()->SpawnActor<ASWeaponPickup>(CurrentWeapon->WeaponPickupClass, SpawnLocation, FRotator::ZeroRotator, SpawnInfo);
if (NewWeaponPickup)
{
/* Apply torque to make it spin when dropped. */
UStaticMeshComponent* MeshComp = NewWeaponPickup->GetMeshComponent();
if (MeshComp)
{
MeshComp->SetSimulatePhysics(true);
MeshComp->AddTorque(FVector(1, 1, 1) * 4000000);
}
}
RemoveWeapon(CurrentWeapon, true);
}
}
void UInfiniteSystemComponent::TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction *ThisTickFunction)
{
Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
// If disabled or we are not attached to a parent component, return.
if (!bIsActive || !AttachParent || !GetWorld()) return;
FVector CamLoc;
FRotator CamRot;
FVector PawnLoc;
FVector NewLoc;
#if WITH_EDITOR
if (GIsEditor)
{
if (!UpdateInEditor) return;
TArray<FVector> viewLocations = GetWorld()->ViewLocationsRenderedLastFrame;
if (viewLocations.Num() != 0)
{
CamLoc = viewLocations[0];
}
//FEditorViewportClient* client = (FEditorViewportClient*)GEditor->GetActiveViewport()->GetClient();
//CamLoc = client->GetViewLocation();
//CamRot = client->GetViewRotation();
if (FollowMethod == LookAtLocation || FollowMethod == FollowCamera)
{
NewLoc = CamLoc;
NewLoc = NewLoc.GridSnap(GridSnapSize);
NewLoc.Z = AttachParent->GetComponentLocation().Z;
AttachParent->SetWorldLocation(NewLoc);
}
else
{
AttachParent->SetRelativeLocation(FVector(0, 0, 0)); //Reset location
}
if (ScaleByDistance && FMath::Abs(CamLoc.Z - AttachParent->GetComponentLocation().Z) > ScaleStartDistance)
{
float DistScale = FMath::Abs(CamLoc.Z - AttachParent->GetComponentLocation().Z) / ScaleDistanceFactor;
DistScale = FMath::Clamp(DistScale, ScaleMin, ScaleMax);
AttachParent->SetRelativeScale3D(FVector(DistScale, DistScale, 1)); //Scale only on x & y axis
}
else if (!ScaleByDistance)
{
AttachParent->SetRelativeScale3D(FVector(1, 1, 1)); //Reset scale
}
return;
}
#endif
if (GetWorld()->WorldType == EWorldType::Game || GetWorld()->WorldType == EWorldType::PIE)
{
if (!GEngine || !GEngine->GetFirstLocalPlayerController(GetWorld())) return;
GEngine->GetFirstLocalPlayerController(GetWorld())->PlayerCameraManager->GetCameraViewPoint(CamLoc, CamRot);
if (GEngine->GetFirstLocalPlayerController(GetWorld())->GetPawn()) //null check
{
PawnLoc = GEngine->GetFirstLocalPlayerController(GetWorld())->GetPawn()->GetActorLocation();
}
else
{
PawnLoc = AttachParent->GetComponentLocation();
}
}
switch (FollowMethod)
{
case LookAtLocation:
if (!FMath::SegmentPlaneIntersection(CamLoc, CamLoc + CamRot.Vector() * MaxLookAtDistance, FPlane(AttachParent->GetComponentLocation(), FVector(0, 0, 1)), NewLoc))
{
NewLoc = CamLoc + CamRot.Vector() * MaxLookAtDistance;
}
break;
case FollowCamera:
NewLoc = CamLoc;
break;
case FollowPawn:
NewLoc = PawnLoc;
break;
default:
break;
};
//UE_LOG(LogTemp, Warning, TEXT("Camera Z Distance from Plane: %f"), FMath::Abs(CamLoc.Z - AttachParent->GetComponentLocation().Z));
if (ScaleByDistance && FMath::Abs(CamLoc.Z - AttachParent->GetComponentLocation().Z) > ScaleStartDistance)
{
float DistScale = FMath::Abs(CamLoc.Z - AttachParent->GetComponentLocation().Z) / ScaleDistanceFactor;
DistScale = FMath::Clamp(DistScale, ScaleMin, ScaleMax);
AttachParent->SetRelativeScale3D(FVector(DistScale, DistScale, 1)); //Scale only on x & y axis
}
if (FollowMethod == Stationary) return;
NewLoc = NewLoc.GridSnap(GridSnapSize);
NewLoc.Z = AttachParent->GetComponentLocation().Z;
AttachParent->SetWorldLocation(NewLoc);
}
// Read motion data from Axis Neuron
bool UPerceptionNeuronBPLibrary::NeuronRead(APerceptionNeuronController *Controller, USkeletalMeshComponent *Mesh, FVector& Translation, FRotator& Rotation, FVector AdditionalTranslation, FRotator AdditionalRotation, EPerceptionNeuronBonesEnum BVHBone, FName CustomBoneName, bool InverseForward)
{
if (Controller == nullptr)
{
if (GEngine)
{
GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("Controller is invalid.")));
}
Rotation.Yaw = Rotation.Pitch = Rotation.Roll = 0;
Translation.X = Translation.Y = Translation.Z = 0;
return false;
}
else if ((Controller->bConnected == false) && (Controller->bPlay == false))
{
Rotation.Yaw = Rotation.Pitch = Rotation.Roll = 0;
Translation.X = Translation.Y = Translation.Z = 0;
return false;
}
int32 BVHBoneIndex = (int32)BVHBone;
if (BVHBoneIndex >= Controller->Skeleton.BoneNr)
{
if (GEngine)
{
GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("Boneindex %d exceeds maximum available bones %d."), BVHBoneIndex, Controller->Skeleton.BoneNr));
}
Rotation.Yaw = Rotation.Pitch = Rotation.Roll = 0;
Translation.X = Translation.Y = Translation.Z = 0;
return false;
}
int32 FloatsPerBone = 6; // 3 for x,y,z translation and 3 for x,y,z rotation
if (Controller->bDisplacement == false)
{
FloatsPerBone = 3; // If there is no displacement (translation) info we have only 3 floats for rotation left
}
if ((BVHBoneIndex * FloatsPerBone) > Controller->FloatCount)
{
Rotation.Yaw = Rotation.Pitch = Rotation.Roll = 0;
Translation.X = Translation.Y = Translation.Z = 0;
return false;
}
// Get the rotation of the reference pose bone
FQuat RefQuat(FQuat::Identity);
if (Mesh != nullptr && Mesh->SkeletalMesh != nullptr)
{
const FReferenceSkeleton& RefSkeleton(Mesh->SkeletalMesh->RefSkeleton);
int32 RefBoneIndex = Mesh->GetBoneIndex(CustomBoneName);
while (RefBoneIndex != INDEX_NONE)
{
RefQuat = RefSkeleton.GetRefBonePose()[RefBoneIndex].GetRotation() * RefQuat;
RefBoneIndex = RefSkeleton.GetParentIndex(RefBoneIndex);
}
}
//
// Translation
//
if (Controller->bDisplacement == true)
{
// Read translation values and remove BVH reference position
float X = Controller->MotionLine[(BVHBoneIndex * FloatsPerBone) + Controller->Skeleton.Bones[BVHBoneIndex].XPos] - Controller->Skeleton.Bones[BVHBoneIndex].Offset[0];
float Y = Controller->MotionLine[(BVHBoneIndex * FloatsPerBone) + Controller->Skeleton.Bones[BVHBoneIndex].YPos] - Controller->Skeleton.Bones[BVHBoneIndex].Offset[1];
float Z = Controller->MotionLine[(BVHBoneIndex * FloatsPerBone) + Controller->Skeleton.Bones[BVHBoneIndex].ZPos] - Controller->Skeleton.Bones[BVHBoneIndex].Offset[2];
// Map BVH translation to UE4 world coordinate system (Inverse if forward direction is -Y)
if (InverseForward)
{
Translation = FVector(-X, -Z, Y);
}
else
{
Translation = FVector(X, Z, Y);
}
// Map UE4 world translation to bone space
Translation = RefQuat.Inverse().RotateVector(Translation);
}
else
{
Translation.X = Translation.Y = Translation.Z = 0;
}
// Add additional translation
Translation.X += AdditionalTranslation.X;
Translation.Y += AdditionalTranslation.Y;
Translation.Z += AdditionalTranslation.Z;
//
// Rotation
//
// Read rotation values and map to pitch, yaw, roll (y, z, x)
float XR = Controller->MotionLine[(BVHBoneIndex * FloatsPerBone) + Controller->Skeleton.Bones[BVHBoneIndex].XRot] * PI / 180.f;
float YR = Controller->MotionLine[(BVHBoneIndex * FloatsPerBone) + Controller->Skeleton.Bones[BVHBoneIndex].YRot] * PI / 180.f;
float ZR = Controller->MotionLine[(BVHBoneIndex * FloatsPerBone) + Controller->Skeleton.Bones[BVHBoneIndex].ZRot] * PI / 180.f;
// Calculate Rotation Matrix and map to Quaternion
FQuat BVHQuat = CalculateQuat(XR, YR, ZR, Controller->Skeleton.Bones[BVHBoneIndex].RotOrder);
// Map BVH rotation to UE4 world coordinate system (Inverse if forward direction is -Y)
float Y = BVHQuat.Y;
float Z = BVHQuat.Z;
if (InverseForward)
{
BVHQuat.X *= -1.0;
BVHQuat.Y = -Z;
BVHQuat.Z = Y;
}
else
{
BVHQuat.Y = Z;
BVHQuat.Z = Y;
}
// Map UE4 world rotation to bone space
FQuat Quat(RefQuat.Inverse() * BVHQuat * RefQuat);
// Add additional rotation
FQuat AddRot(AdditionalRotation);
Quat *= AddRot;
// Convert to Rotator
Rotation = Quat.Rotator();
Rotation.Normalize();
return true;
}