void ABrowserCharacter::MoveUp(float Val)
{
if ((Val != 0.0f) && (Controller != NULL) && bEnable3D)
{
const FRotator Rotation = Controller->GetControlRotation();
const FRotationMatrix R = FRotationMatrix(FRotator(Rotation.Pitch, 0, Rotation.Roll));
const FVector WorldSpaceAccel = R.GetScaledAxis(EAxis::Z);
AddMovementInput(WorldSpaceAccel, Val * SpeedZ * (CHARACTER_MOVEMENT_SPEED(cameraZoom_current)));
}
}
void ABrowserCharacter::MoveRight(float Val)
{
if ((Val != 0.0f) && (Controller != NULL))
{
const FRotator Rotation = Controller->GetControlRotation();
const FRotationMatrix R = FRotationMatrix(FRotator(0, Rotation.Yaw, 0));
const FVector WorldSpaceAccel = R.GetScaledAxis(EAxis::Y);
AddMovementInput(WorldSpaceAccel, Val * SpeedY * (CHARACTER_MOVEMENT_SPEED(cameraZoom_current)));
}
}
void UCameraAnimInst::ApplyToView(FMinimalViewInfo& InOutPOV) const
{
if (CurrentBlendWeight > 0.f)
{
ACameraActor const* AnimatedCamActor = dynamic_cast<ACameraActor*>(InterpGroupInst->GetGroupActor());
if (AnimatedCamActor)
{
if (CamAnim->bRelativeToInitialTransform)
{
// move animated cam actor to initial-relative position
FTransform const AnimatedCamToWorld = AnimatedCamActor->GetTransform();
FTransform const AnimatedCamToInitialCam = AnimatedCamToWorld * InitialCamToWorld.Inverse();
ACameraActor* const MutableCamActor = const_cast<ACameraActor*>(AnimatedCamActor);
MutableCamActor->SetActorTransform(AnimatedCamToInitialCam);
}
float const Scale = CurrentBlendWeight;
FRotationMatrix const CameraToWorld(InOutPOV.Rotation);
if (PlaySpace == ECameraAnimPlaySpace::CameraLocal)
{
// the code in the else block will handle this just fine, but this path provides efficiency and simplicity for the most common case
// loc
FVector const LocalOffset = CameraToWorld.TransformVector(AnimatedCamActor->GetActorLocation()*Scale);
InOutPOV.Location += LocalOffset;
// rot
FRotationMatrix const AnimRotMat(AnimatedCamActor->GetActorRotation()*Scale);
InOutPOV.Rotation = (AnimRotMat * CameraToWorld).Rotator();
}
else
{
// handle playing the anim in an arbitrary space relative to the camera
// find desired space
FMatrix const PlaySpaceToWorld = (PlaySpace == ECameraAnimPlaySpace::UserDefined) ? UserPlaySpaceMatrix : FMatrix::Identity;
// loc
FVector const LocalOffset = PlaySpaceToWorld.TransformVector(AnimatedCamActor->GetActorLocation()*Scale);
InOutPOV.Location += LocalOffset;
// rot
// find transform from camera to the "play space"
FMatrix const CameraToPlaySpace = CameraToWorld * PlaySpaceToWorld.Inverse(); // CameraToWorld * WorldToPlaySpace
// find transform from anim (applied in playspace) back to camera
FRotationMatrix const AnimToPlaySpace(AnimatedCamActor->GetActorRotation()*Scale);
FMatrix const AnimToCamera = AnimToPlaySpace * CameraToPlaySpace.Inverse(); // AnimToPlaySpace * PlaySpaceToCamera
// RCS = rotated camera space, meaning camera space after it's been animated
// this is what we're looking for, the diff between rotated cam space and regular cam space.
// apply the transform back to camera space from the post-animated transform to get the RCS
FMatrix const RCSToCamera = CameraToPlaySpace * AnimToCamera;
// now apply to real camera
FRotationMatrix const RealCamToWorld(InOutPOV.Rotation);
InOutPOV.Rotation = (RCSToCamera * RealCamToWorld).Rotator();
}
// fov
if (bHasFOVTrack)
{
const float FOVMin = 5.f;
const float FOVMax = 170.f;
// Interp the FOV toward the camera component's FOV based on Scale
if (CamAnim->bRelativeToInitialFOV)
{
InOutPOV.FOV += (AnimatedCamActor->GetCameraComponent()->FieldOfView - InitialFOV) * Scale;
}
else
{
const int32 DesiredDirection = FMath::Sign(AnimatedCamActor->GetCameraComponent()->FieldOfView - InOutPOV.FOV);
const int32 InitialDirection = FMath::Sign(AnimatedCamActor->GetCameraComponent()->FieldOfView - InitialFOV);
if (DesiredDirection != InitialDirection)
{
InOutPOV.FOV = FMath::Clamp(InOutPOV.FOV + ((AnimatedCamActor->GetCameraComponent()->FieldOfView - InOutPOV.FOV) * Scale), InOutPOV.FOV, AnimatedCamActor->GetCameraComponent()->FieldOfView);
}
else
{
InOutPOV.FOV = FMath::Clamp(InOutPOV.FOV + ((AnimatedCamActor->GetCameraComponent()->FieldOfView - InitialFOV) * Scale), AnimatedCamActor->GetCameraComponent()->FieldOfView, InitialFOV);
}
}
InOutPOV.FOV = FMath::Clamp<float>(InOutPOV.FOV, FOVMin, FOVMax);
}
}
}
}
void AStrategyHUD::DrawMiniMap()
{
const AStrategyPlayerController* const PC = Cast<AStrategyPlayerController>(PlayerOwner);
AStrategyGameState const* const MyGameState = GetWorld()->GetGameState<AStrategyGameState>();
// @todo, clean this up
if (PC && MyGameState && MyGameState->MiniMapCamera.IsValid())
{
const float BaseRotation = 270;
UTexture* MiniMapTexture = Cast<UTexture>(MyGameState->MiniMapCamera->GetCaptureComponent2D()->TextureTarget);
const float MapWidth = (MyGameState->MiniMapCamera->MiniMapWidth - MiniMapMargin) * UIScale;
const float MapHeight = (MyGameState->MiniMapCamera->MiniMapHeight - MiniMapMargin) * UIScale;
const FVector WorldCenter = MyGameState->WorldBounds.GetCenter();
const FVector WorldExtent = MyGameState->WorldBounds.GetExtent();
const FRotator RotOrg = MyGameState->MiniMapCamera->GetCaptureComponent2D()->GetComponentRotation();
const FRotationMatrix RotationMatrix(FRotator(0,BaseRotation-RotOrg.Roll,0));
const FVector2D Offset(MiniMapMargin * UIScale + (MapWidth/2.0f), Canvas->ClipY - (MapHeight/2.0f) - MiniMapMargin * UIScale );
if (MiniMapTexture)
{
FCanvasTileItem MapTileItem( FVector2D( 0.0f, 0.0f), FVector2D( 0.0f, 0.0f ), FLinearColor::White );
MapTileItem.Texture = MiniMapTexture->Resource;
MapTileItem.Size = FVector2D( MapWidth, MapHeight );
MapTileItem.BlendMode = SE_BLEND_Opaque;
Canvas->DrawItem( MapTileItem, FVector2D( MiniMapMargin * UIScale, Canvas->ClipY - MapHeight - MiniMapMargin * UIScale ) );
}
FCanvasTileItem TileItem( FVector2D( 0.0f, 0.0f), FVector2D( 0.0f, 0.0f ), FLinearColor::White );
TileItem.Size = FVector2D( 6 * UIScale, 6 * UIScale );
for (FConstPawnIterator Iterator = GetWorld()->GetPawnIterator(); Iterator; ++Iterator)
{
AStrategyChar* TestChar = Cast<AStrategyChar>(*Iterator);
if (TestChar != NULL && TestChar->GetHealth() > 0 )
{
AStrategyAIController* AIController = Cast<AStrategyAIController>(TestChar->Controller);
if (AIController != NULL && AIController->IsLogicEnabled())
{
FLinearColor DrawColor;
if (PC != NULL && TestChar->GetTeamNum() == PC->GetTeamNum())
{
DrawColor = FColor( 49, 137, 253, 255);
}
else
{
DrawColor = FColor( 242, 114, 16, 255);
}
const FVector CenterRelativeLocation = RotationMatrix.TransformPosition(TestChar->GetActorLocation() - WorldCenter);
const FVector2D MiniMapPoint = FVector2D(CenterRelativeLocation.X / WorldExtent.X, CenterRelativeLocation.Y / WorldExtent.Y);
TileItem.SetColor( DrawColor );
Canvas->DrawItem( TileItem, FVector2D( Offset.X + MiniMapPoint.X * (MapWidth/2.0f), Offset.Y + MiniMapPoint.Y * (MapHeight/2.0f) ) );
}
}
}
ULocalPlayer* MyPlayer = Cast<ULocalPlayer>(PC->Player);
FVector2D ScreenCorners[4] = { FVector2D(0, 0), FVector2D(Canvas->ClipX, 0), FVector2D(Canvas->ClipX, Canvas->ClipY), FVector2D(0, Canvas->ClipY) };
const FPlane GroundPlane = FPlane(FVector(0, 0, MyGameState->WorldBounds.Max.Z), FVector::UpVector);
for (int32 i = 0; i < 4; i++)
{
FVector RayOrigin, RayDirection;
FStrategyHelpers::DeprojectScreenToWorld(ScreenCorners[i], MyPlayer, RayOrigin, RayDirection);
const FVector GroundPoint = FStrategyHelpers::IntersectRayWithPlane(RayOrigin, RayDirection, GroundPlane);
const FVector CenterRelativeLocation = RotationMatrix.TransformPosition(GroundPoint - WorldCenter);
MiniMapPoints[i] = FVector2D(CenterRelativeLocation.X / WorldExtent.X, CenterRelativeLocation.Y / WorldExtent.Y);
}
}
}
void APlayerCameraManager::ApplyAnimToCamera(ACameraActor const* AnimatedCamActor, UCameraAnimInst const* AnimInst, FMinimalViewInfo& InOutPOV)
{
if (AnimInst->CamAnim->bRelativeToInitialTransform)
{
// move animated cam actor to initial-relative position
FTransform const AnimatedCamToWorld = AnimatedCamActor->GetTransform();
FTransform const AnimatedCamToInitialCam = AnimatedCamToWorld * AnimInst->InitialCamToWorld.Inverse();
ACameraActor* const MutableCamActor = const_cast<ACameraActor*>(AnimatedCamActor);
MutableCamActor->SetActorTransform(AnimatedCamToInitialCam);
}
float const Scale = AnimInst->CurrentBlendWeight;
FRotationMatrix const CameraToWorld(InOutPOV.Rotation);
if (AnimInst->PlaySpace == ECameraAnimPlaySpace::CameraLocal)
{
// the code in the else block will handle this just fine, but this path provides efficiency and simplicity for the most common case
// loc
FVector const LocalOffset = CameraToWorld.TransformVector( AnimatedCamActor->GetActorLocation()*Scale );
InOutPOV.Location += LocalOffset;
// rot
FRotationMatrix const AnimRotMat( AnimatedCamActor->GetActorRotation()*Scale );
InOutPOV.Rotation = (AnimRotMat * CameraToWorld).Rotator();
}
else
{
// handle playing the anim in an arbitrary space relative to the camera
// find desired space
FMatrix const PlaySpaceToWorld = (AnimInst->PlaySpace == ECameraAnimPlaySpace::UserDefined) ? AnimInst->UserPlaySpaceMatrix : FMatrix::Identity;
// loc
FVector const LocalOffset = PlaySpaceToWorld.TransformVector( AnimatedCamActor->GetActorLocation()*Scale );
InOutPOV.Location += LocalOffset;
// rot
// find transform from camera to the "play space"
FMatrix const CameraToPlaySpace = CameraToWorld * PlaySpaceToWorld.Inverse(); // CameraToWorld * WorldToPlaySpace
// find transform from anim (applied in playspace) back to camera
FRotationMatrix const AnimToPlaySpace(AnimatedCamActor->GetActorRotation()*Scale);
FMatrix const AnimToCamera = AnimToPlaySpace * CameraToPlaySpace.Inverse(); // AnimToPlaySpace * PlaySpaceToCamera
// RCS = rotated camera space, meaning camera space after it's been animated
// this is what we're looking for, the diff between rotated cam space and regular cam space.
// apply the transform back to camera space from the post-animated transform to get the RCS
FMatrix const RCSToCamera = CameraToPlaySpace * AnimToCamera;
// now apply to real camera
FRotationMatrix const RealCamToWorld(InOutPOV.Rotation);
InOutPOV.Rotation = (RCSToCamera * RealCamToWorld).Rotator();
}
// fov
const float FOVMin = 5.f;
const float FOVMax = 170.f;
InOutPOV.FOV += (AnimatedCamActor->GetCameraComponent()->FieldOfView - AnimInst->InitialFOV) * Scale;
InOutPOV.FOV = FMath::Clamp<float>(InOutPOV.FOV, FOVMin, FOVMax);
// postprocess
if (AnimatedCamActor->GetCameraComponent()->PostProcessBlendWeight > 0.f)
{
AddCachedPPBlend(AnimatedCamActor->GetCameraComponent()->PostProcessSettings, AnimatedCamActor->GetCameraComponent()->PostProcessBlendWeight);
}
}
void UBerserkCameraComponent::MoveRight(float value)
{
auto ownerPawn = GetOwnerPawn();
if (ownerPawn != nullptr)
{
auto playerController = GetPlayerController();
if ((value != 0.f) && (playerController != nullptr))
{
const FRotationMatrix cameraRotation(playerController->PlayerCameraManager->GetCameraRotation());
const FVector worldSpaceAccel = cameraRotation.GetScaledAxis(EAxis::Y) * 100.0f;
// transform to world space and add it
ownerPawn->AddMovementInput(worldSpaceAccel, value);
}
}
}