So I copied both whole of SpringArmComponent files (.cpp and .h) so I could have the Camera Lag to be applied to Z location only.
Something like: X and Y Locations to have the Camera Lag Speed to be set to 0 while Z to 5.
But I’m stuck in this loop. I tried everything to fix it, but not even Copilot is able to help me (and I’m not ashamed that I was forced to use the Copilot to help myself a little).
VInterpTo is for vectors.
Use FInterpTo for floats.
Also, instead of copying entire file, make a subclass of SpringArmComponent and override only function UpdateDesiredArmLocation.
You can’t just use local variables which are declared in the Super’s.
Looked a bit at the code, I’m afraid you’ll still have to copypaste the entire function to apply your changes in. It’s not great, but still better than the entire class.
Copied entire “UpdateDesiredArmLocation” function (or I think it’s a function) to the subclass, but not to avail. More errors.
Here’s the entire part of the code:
UCndPlayerSpringArmComponent::UCndPlayerSpringArmComponent()
{
// <STUDIO_NAME_HERE> Customs
bLagFixedXYLocation = true;
}
void UCndPlayerSpringArmComponent::UpdateDesiredArmLocation(bool bDoTrace, bool bDoLocationLag, bool bDoRotationLag, float DeltaTime)
{
FRotator DesiredRot = GetTargetRotation();
// If our viewtarget is simulating using physics, we may need to clamp deltatime
if (bClampToMaxPhysicsDeltaTime)
{
// Use the same max timestep cap as the physics system to avoid camera jitter when the viewtarget simulates less time than the camera
DeltaTime = FMath::Min(DeltaTime, UPhysicsSettings::Get()->MaxPhysicsDeltaTime);
}
// Apply 'lag' to rotation if desired
if (bDoRotationLag)
{
if (bUseCameraLagSubstepping && DeltaTime > CameraLagMaxTimeStep && CameraRotationLagSpeed > 0.f)
{
const FRotator ArmRotStep = (DesiredRot - PreviousDesiredRot).GetNormalized() * (1.f / DeltaTime);
FRotator LerpTarget = PreviousDesiredRot;
float RemainingTime = DeltaTime;
while (RemainingTime > UE_KINDA_SMALL_NUMBER)
{
const float LerpAmount = FMath::Min(CameraLagMaxTimeStep, RemainingTime);
LerpTarget += ArmRotStep * LerpAmount;
RemainingTime -= LerpAmount;
DesiredRot = FRotator(FMath::QInterpTo(FQuat(PreviousDesiredRot), FQuat(LerpTarget), LerpAmount, CameraRotationLagSpeed));
PreviousDesiredRot = DesiredRot;
}
}
else
{
DesiredRot = FRotator(FMath::QInterpTo(FQuat(PreviousDesiredRot), FQuat(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 actual camera position, so rotating the camera around does not have lag
FVector DesiredLoc = ArmOrigin;
if (bDoLocationLag)
{
if (bUseCameraLagSubstepping && DeltaTime > CameraLagMaxTimeStep && CameraLagSpeed > 0.f)
{
const FVector ArmMovementStep = (DesiredLoc - PreviousDesiredLoc) * (1.f / DeltaTime);
FVector LerpTarget = PreviousDesiredLoc;
float RemainingTime = DeltaTime;
while (RemainingTime > UE_KINDA_SMALL_NUMBER)
{
const float LerpAmount = FMath::Min(CameraLagMaxTimeStep, RemainingTime);
LerpTarget += ArmMovementStep * LerpAmount;
RemainingTime -= LerpAmount;
// <STUDIO_NAME_HERE> Customs
// Apply Camera Lag and Camera Lag Speed for Z location only.
if (bLagFixedXYLocation)
{
FVector DesiredLoc = LerpTarget;
DesiredLoc = FMath::FInterpTo(PreviousDesiredLoc.Z, LerpTarget.Z, LerpAmount, CameraLagSpeed);
}
else
{
DesiredLoc = FMath::VInterpTo(PreviousDesiredLoc, LerpTarget, LerpAmount, CameraLagSpeed);
PreviousDesiredLoc = DesiredLoc;
}
}
}
else
{
DesiredLoc = FMath::VInterpTo(PreviousDesiredLoc, DesiredLoc, DeltaTime, CameraLagSpeed);
}
// Clamp distance if requested
bool bClampedDist = false;
if (CameraLagMaxDistance > 0.f)
{
const FVector FromOrigin = DesiredLoc - ArmOrigin;
if (FromOrigin.SizeSquared() > FMath::Square(CameraLagMaxDistance))
{
DesiredLoc = ArmOrigin + FromOrigin.GetClampedToMaxSize(CameraLagMaxDistance);
bClampedDist = true;
}
}
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
if (bDrawDebugLagMarkers)
{
DrawDebugSphere(GetWorld(), ArmOrigin, 5.f, 8, FColor::Green);
DrawDebugSphere(GetWorld(), DesiredLoc, 5.f, 8, FColor::Yellow);
const FVector ToOrigin = ArmOrigin - DesiredLoc;
DrawDebugDirectionalArrow(GetWorld(), DesiredLoc, DesiredLoc + ToOrigin * 0.5f, 7.5f, bClampedDist ? FColor::Red : FColor::Green);
DrawDebugDirectionalArrow(GetWorld(), DesiredLoc + ToOrigin * 0.5f, ArmOrigin, 7.5f, bClampedDist ? FColor::Red : FColor::Green);
}
#endif
}
PreviousArmOrigin = ArmOrigin;
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))
{
bIsCameraFixed = true;
FCollisionQueryParams QueryParams(SCENE_QUERY_STAT(SpringArm), false, GetOwner());
FHitResult Result;
GetWorld()->SweepSingleByChannel(Result, ArmOrigin, DesiredLoc, FQuat::Identity, ProbeChannel, FCollisionShape::MakeSphere(ProbeSize), QueryParams);
UnfixedCameraPosition = DesiredLoc;
ResultLoc = BlendLocations(DesiredLoc, Result.Location, Result.bBlockingHit, DeltaTime);
if (ResultLoc == DesiredLoc)
{
bIsCameraFixed = false;
}
}
else
{
ResultLoc = DesiredLoc;
bIsCameraFixed = false;
UnfixedCameraPosition = ResultLoc;
}
// Form a transform for new world transform for camera
FTransform WorldCamTM(DesiredRot, ResultLoc);
// Convert to relative to component
FTransform RelCamTM = WorldCamTM.GetRelativeTransform(GetComponentTransform());
// Update socket location/rotation
RelativeSocketLocation = RelCamTM.GetLocation();
RelativeSocketRotation = RelCamTM.GetRotation();
UpdateChildTransforms();
}
Okay, did some thinkering (and/with Copilot), and finally managed to get it working.
The Camera Lag is finally fixed to Z location. X and Y locations are fixed too with this code, with copypasted UpdateDesiredArmLocation function.
PART OF THE CODE TO REMOVE TO MAKE IT WORK
// If our viewtarget is simulating using physics, we may need to clamp deltatime
if (bClampToMaxPhysicsDeltaTime)
{
// Use the same max timestep cap as the physics system to avoid camera jitter when the viewtarget simulates less time than the camera
DeltaTime = FMath::Min(DeltaTime, UPhysicsSettings::Get()->MaxPhysicsDeltaTime);
}
FVector DesiredLoc = ArmOrigin;
if (bDoLocationLag)
{
if (bUseCameraLagSubstepping && DeltaTime > CameraLagMaxTimeStep && CameraLagSpeed > 0.f)
{
const FVector ArmMovementStep = (DesiredLoc - PreviousDesiredLoc) * (1.f / DeltaTime);
FVector LerpTarget = PreviousDesiredLoc;
float RemainingTime = DeltaTime;
while (RemainingTime > UE_KINDA_SMALL_NUMBER)
{
const float LerpAmount = FMath::Min(CameraLagMaxTimeStep, RemainingTime);
LerpTarget += ArmMovementStep * LerpAmount;
RemainingTime -= LerpAmount;
// <STUDIO_NAME_HERE> Customs
// Apply Camera Lag and Camera Lag Speed for Z location only.
if (bLagFixedXYLocation)
{
// Update Z component directly
DesiredLoc.Z = FMath::FInterpTo(PreviousDesiredLoc.Z, LerpTarget.Z, LerpAmount, CameraLagSpeed);
}
else
{
// Update DesiredLoc using VInterpTo
DesiredLoc = FMath::VInterpTo(PreviousDesiredLoc, LerpTarget, LerpAmount, CameraLagSpeed);
PreviousDesiredLoc = DesiredLoc;
}
I think I can call this one as Solved.
This topic was automatically closed 30 days after the last reply. New replies are no longer allowed.