UCrosshairWidget Class Reference

#include <CrosshairWidget.h>

Inheritance diagram for UCrosshairWidget:

Public Member Functions
void	OnHitMarker (const AActor *ActorHit, const float Damage, const UDamageType *DamageType, const FName HitBone, const FVector HitLocation, const bool bKillingHit, const bool bInjuredPart)
virtual void	HitMarker (const AActor *ActorHit, const float Damage, const UDamageType *DamageType, const FName HitBone, const FVector HitLocation, const bool bKillingHit, const bool bInjuredPart) override
virtual void	GunRecoil (const float RecoilAmount) override
void	SetCrosshairLocation ()
void	SetCrosshairRadius ()
void	SetGunRecoil (const float RecoilAmount)
virtual void	StartedAiming () override
virtual void	StoppedAiming () override
void	OnStartedAiming ()
void	OnStoppedAiming ()
virtual void	SetHolstered (const bool bIsHolstered) override
void	OnHolsteredSet (const bool bIsHolstered)
virtual void	SetWeaponCrosshair (const FCrosshairData &CrosshairType, const float Spread) override
void	OnSetWeaponCrosshair (const FCrosshairData &CrosshairType, const float Spread)
Public Member Functions inherited from ICrosshairInterface
virtual void	SetWeaponCrosshair (const struct FCrosshairData &CrosshairType, const float Spread)=0

Protected Member Functions
virtual bool	Initialize () override
virtual void	NativeConstruct () override
void	VisibilityChangedEvent (ESlateVisibility InVisibility)

Protected Attributes
float	InterpSpeed = 12.0f
float	UpperBound = -80.0f
float	LowerBound = 25.0f
float	RecoilMultiplier = 20.0f
float	PlayerSpeedMultiplier = 0.15f
float	WeaponSpreadMultiplier = 0.15f
float	UpdateSpeed = 0.03f
float	CrosshairOpacityLow = 0.2f
bool	bShowDamageNumbers = false
bool	bShowDamageHitDot = false
UWidget *	DamageVerticalBox = nullptr
UWidget *	HitMarkerWidget = nullptr
UTextBlock *	DamageAmount = nullptr
class UCircumferenceMarkerWidget *	Crosshairs = nullptr
class UWidget *	HitMarkers = nullptr
UWidget *	CrosshairOverlay = nullptr
class USizeBox *	ReticleSizeBox = nullptr
class UImage *	OuterImage = nullptr
class UImage *	OuterImageHorizontal = nullptr
bool	bHolstered = true
bool	bAiming = false
int32	CrosshairStyle = 0
FCrosshairData	CrosshairData
float	WeaponSpread = 0.0f

Private Member Functions
void	SetDamagePosition (const FVector &Location) const
void	SetCrosshairOpacity () const
void	SetReticleSize (const float Radius) const
void	SetHitMarkerVisibility (const float Alpha) const
float	ProcessNumbers (const class UCanvasPanelSlot *CanvasSlot, const bool bVertical) const
float	ComputeMaxScreenspaceSpreadRadius () const

Private Attributes
FTimerHandle	HitMarkerTimerHandle
FTimerHandle	CrosshairUpdateTimerHandle
float	Recoil
bool	bRecoilFire = false

Detailed Description

UCrosshairWidget is a user widget that represents a weapon crosshair in the UI.

Member Function Documentation

ComputeMaxScreenspaceSpreadRadius()

float UCrosshairWidget::ComputeMaxScreenspaceSpreadRadius ( ) const

private

{
    const float LongShotDistance = 10000.0f;
    APlayerController* PlayerController = GetOwningPlayer();
    if(PlayerController != nullptr && PlayerController->PlayerCameraManager != nullptr)
    {
        const FVector PlayerVelocity = GetOwningPlayerPawn()->GetVelocity();
        const float PlayerSpeed = ((PlayerVelocity.Size() * -1.0f) * PlayerSpeedMultiplier);
        const float DeltaSeconds = GetWorld()->GetDeltaSeconds();
    
        float Target = PlayerSpeed;
        if(bRecoilFire)
        {
            Target = PlayerSpeed + (Recoil * -1.0f);    
        }
        // const float Current = Crosshairs->Radius;
        // const float ClampValue = UKismetMathLibrary::FInterpTo(Current, Target, DeltaSeconds, InterpSpeed);
        // const float ClampedRadius =  UKismetMathLibrary::FClamp(ClampValue, CrosshairData.ReticleSize.RadiusUpperBounds, CrosshairData.ReticleSize.RadiusLowerBounds);
 
        
        const float SpreadRadiusRads = FMath::DegreesToRadians(WeaponSpread * WeaponSpreadMultiplier - Target);
        const float SpreadRadiusAtDistance = FMath::Tan(SpreadRadiusRads) * LongShotDistance;
        FVector CamPos;
        FRotator CamOrient;
        PlayerController->PlayerCameraManager->GetCameraViewPoint(CamPos, CamOrient);
        FVector CamForwDir = CamOrient.RotateVector(FVector::ForwardVector);
        FVector CamUpDir   = CamOrient.RotateVector(FVector::UpVector);
 
        FVector OffsetTargetAtDistance = CamPos + (CamForwDir * LongShotDistance) + (CamUpDir * SpreadRadiusAtDistance);
 
        FVector2D OffsetTargetInScreenspace;
 
        if (PlayerController->ProjectWorldLocationToScreen(OffsetTargetAtDistance, OffsetTargetInScreenspace, true))
        {
            int32 ViewportSizeX(0), ViewportSizeY(0);
            PlayerController->GetViewportSize(ViewportSizeX, ViewportSizeY);
 
            const FVector2D ScreenSpaceCenter(FVector::FReal(ViewportSizeX) * 0.5f, FVector::FReal(ViewportSizeY) * 0.5f);
 
            return (OffsetTargetInScreenspace - ScreenSpaceCenter).Length();
        }
    }
    return 0.0f;
}

GunRecoil()

void UCrosshairWidget::GunRecoil ( const float RecoilAmount )

overridevirtual

Implements ICrosshairInterface.

{
    SetGunRecoil(RecoilAmount);
}

HitMarker()

void UCrosshairWidget::HitMarker ( const AActor * ActorHit, const float Damage, const UDamageType * DamageType, const FName HitBone, const FVector HitLocation, const bool bKillingHit, const bool bInjuredPart )

overridevirtual

Implements ICrosshairInterface.

{
    OnHitMarker(ActorHit, Damage, DamageType, HitBone, HitLocation, bKillingHit, bInjuredPart);
    if(HitMarkers != nullptr)
    {
        IHitMarkerInterface* HitMarkerInterface = Cast<IHitMarkerInterface>(HitMarkers);
        if(HitMarkerInterface != nullptr)
        {
            HitMarkerInterface->HitMarker(ActorHit, Damage, DamageType, HitBone, HitLocation, bKillingHit, bInjuredPart);
        }
    }
    SetDamagePosition(HitLocation);
    if(DamageAmount != nullptr)
    {
        DamageAmount->SetRenderOpacity(1.0f);
        DamageAmount->SetText(FText::FromString(FString::Printf(TEXT("%.0f"), Damage)));
    }
    if(HitMarkerWidget != nullptr)
    {
        HitMarkerWidget->SetRenderOpacity(1.0f);
    }
    if(DamageVerticalBox != nullptr)
    {
        DamageVerticalBox->SetRenderOpacity(1.0f);
    }
}

Initialize()

bool UCrosshairWidget::Initialize ( )

overrideprotectedvirtual

{
    const bool bSuccess = Super::Initialize();
    if (!ensure(OuterImage != nullptr)) return false;
    if (!ensure(OuterImageHorizontal != nullptr)) return false;    
    if (!ensure(HitMarkerWidget != nullptr)) return false;
    if (!ensure(Crosshairs != nullptr)) return false;
    if (!ensure(DamageAmount != nullptr)) return false;
    if (!ensure(CrosshairOverlay != nullptr)) return false;
    if (!ensure(DamageVerticalBox != nullptr)) return false;
    if (!ensure(ReticleSizeBox != nullptr)) return false;
    
    OnVisibilityChanged.AddUniqueDynamic(this, &UCrosshairWidget::VisibilityChangedEvent);
    if(!bSuccess) return false;
    return true;
}

NativeConstruct()

void UCrosshairWidget::NativeConstruct ( )

overrideprotectedvirtual

{
    Super::NativeConstruct();
    if(HitMarkerWidget != nullptr)
    {
        HitMarkerWidget->SetRenderOpacity(0.0f);
    }
    if(DamageAmount != nullptr)
    {
        DamageAmount->SetRenderOpacity(0.0f);
    }
    if(CrosshairOverlay != nullptr)
    {
        CrosshairOverlay->SetRenderOpacity(0.0f);
    }
    if(HitMarkers != nullptr)
    {
        HitMarkers->SetVisibility(ESlateVisibility::HitTestInvisible);
    }
    if(GetOwningPlayer() != nullptr)
    {
        GetOwningPlayer()->GetWorldTimerManager().SetTimer(CrosshairUpdateTimerHandle, this, &UCrosshairWidget::SetCrosshairLocation, UpdateSpeed, true);
    }
    if(DamageVerticalBox != nullptr)
    {
        if(bShowDamageHitDot)
        {
            DamageVerticalBox->SetVisibility(ESlateVisibility::HitTestInvisible);
        }
        else
        {
            DamageVerticalBox->SetVisibility(ESlateVisibility::Collapsed);
        }
    }
    if(DamageAmount != nullptr)
    {
        if(bShowDamageNumbers)
        {
            DamageAmount->SetVisibility(ESlateVisibility::HitTestInvisible);
        }
        else
        {
            DamageAmount->SetVisibility(ESlateVisibility::Collapsed);
        }
    }
}

OnHitMarker()

void UCrosshairWidget::OnHitMarker	(	const AActor *	ActorHit,
		const float	Damage,
		const UDamageType *	DamageType,
		const FName	HitBone,
		const FVector	HitLocation,
		const bool	bKillingHit,
		const bool	bInjuredPart )

OnHolsteredSet()

void UCrosshairWidget::OnHolsteredSet

(

const bool

bIsHolstered

)

OnSetWeaponCrosshair()

void UCrosshairWidget::OnSetWeaponCrosshair	(	const FCrosshairData &	CrosshairType,
		const float	Spread )

OnStartedAiming()

void UCrosshairWidget::OnStartedAiming

(

)

OnStoppedAiming()

void UCrosshairWidget::OnStoppedAiming

(

)

ProcessNumbers()

float UCrosshairWidget::ProcessNumbers ( const class UCanvasPanelSlot * CanvasSlot, const bool bVertical ) const

private

{
    const FVector PlayerVelocity = GetOwningPlayerPawn()->GetVelocity();
    const float PlayerSpeed = ((PlayerVelocity.Size() * -1.0f) * PlayerSpeedMultiplier);
    const float DeltaSeconds = GetWorld()->GetDeltaSeconds();
    
    float Target = PlayerSpeed;
    if(bRecoilFire)
    {
        Target = PlayerSpeed + (Recoil * -1.0f);    
    }
    float Current = CanvasSlot->GetPosition().X;
    if(bVertical)
    {
        Current = CanvasSlot->GetPosition().Y;
    }
    const float ClampValue = UKismetMathLibrary::FInterpTo(Current, Target, DeltaSeconds, InterpSpeed);
    return UKismetMathLibrary::FClamp(ClampValue, UpperBound, LowerBound);
}

SetCrosshairLocation()

void UCrosshairWidget::SetCrosshairLocation

(

)

{
    if(!GetOwningPlayer()->IsLocalController()){return;}
    if(GetOwningPlayerPawn() == nullptr){/*UE_LOG(LogTemp,Warning,TEXT("Error getting Player Pawn - CrosshairWidget"));*/return;}
    SetCrosshairRadius();
    Recoil = 0;
    bRecoilFire = false;
}

SetCrosshairOpacity()

void UCrosshairWidget::SetCrosshairOpacity ( ) const

private

{
    if(CrosshairOverlay == nullptr){return;}
    if(bHolstered)
    {
        CrosshairOverlay->SetRenderOpacity(0.0f);
    }
    else
    {
        if(bAiming)
        {
            CrosshairOverlay->SetRenderOpacity(1.0f);
        }
        else
        {
            CrosshairOverlay->SetRenderOpacity(CrosshairOpacityLow);
        }
    }
}

SetCrosshairRadius()

void UCrosshairWidget::SetCrosshairRadius

(

)

Old Way of Calculating //

/// / / / / / /

{
    // const FVector PlayerVelocity = GetOwningPlayerPawn()->GetVelocity();
    // const float PlayerSpeed = ((PlayerVelocity.Size() * -1.0f) * PlayerSpeedMultiplier);
    const float DeltaSeconds = GetWorld()->GetDeltaSeconds();
    //
    // float Target = PlayerSpeed;
    // if(bRecoilFire)
    // {
    //  Target = PlayerSpeed + (Recoil * -1.0f);    
    // }
    // const float Current = Crosshairs->Radius;
    // const float ClampValue = UKismetMathLibrary::FInterpTo(Current, Target, DeltaSeconds, InterpSpeed);
    // const float ClampedRadius =  UKismetMathLibrary::FClamp(ClampValue, UpperBound, LowerBound);
 
    const float NewRadius = ComputeMaxScreenspaceSpreadRadius();
    const float Current = Crosshairs->Radius;
    const float ClampValue = UKismetMathLibrary::FInterpTo(Current, NewRadius, DeltaSeconds, InterpSpeed);
    //- New Method  //
    if(CrosshairData.bHasMaxCrosshairRadius)
    {
        Crosshairs->SetRadius(CrosshairData.MaxCrosshairRadius);
    }
    else
    {
        Crosshairs->SetRadius(ClampValue);
        // Crosshairs->SetRadius(ClampedRadius);
    }
    SetReticleSize(ClampValue);
 
    
    Recoil = 0;
    bRecoilFire = false;
}

SetDamagePosition()

void UCrosshairWidget::SetDamagePosition ( const FVector & Location ) const

private

{
    if(GetOwningPlayer() == nullptr){return;}
    if(DamageVerticalBox == nullptr){return;}
    UCanvasPanelSlot* CanvasPanelSlot = Cast<UCanvasPanelSlot>(DamageVerticalBox->Slot);
    if(CanvasPanelSlot == nullptr){return;}
 
    FVector2D ScreenLocation;
    if(UWidgetLayoutLibrary::ProjectWorldLocationToWidgetPosition(GetOwningPlayer(), Location, ScreenLocation, true))
    {
        CanvasPanelSlot->SetPosition(ScreenLocation);       
    }
}

SetGunRecoil()

void UCrosshairWidget::SetGunRecoil

(

const float

RecoilAmount

)

{
    Recoil = (RecoilAmount * RecoilMultiplier);
    bRecoilFire = true;
}

SetHitMarkerVisibility()

void UCrosshairWidget::SetHitMarkerVisibility ( const float Alpha ) const

private

{
    const float Opacity = UKismetMathLibrary::Lerp(0, 1, Alpha);
    HitMarkerWidget->SetRenderOpacity(Opacity);
}

SetHolstered()

void UCrosshairWidget::SetHolstered ( const bool bIsHolstered )

overridevirtual

Implements ICrosshairInterface.

{
    bHolstered = bIsHolstered;
    SetCrosshairOpacity();
    OnHolsteredSet(bHolstered);
}

SetReticleSize()

void UCrosshairWidget::SetReticleSize ( const float Radius ) const

private

{
    ReticleSizeBox->SetHeightOverride(CrosshairData.ReticleSize.GetCrosshairSize(Radius));
    ReticleSizeBox->SetWidthOverride(CrosshairData.ReticleSize.GetCrosshairSize(Radius));
    if(CrosshairData.bUseSeparateHorizontal)
    {
        ReticleSizeBox->SetWidthOverride(CrosshairData.ReticleHorizontalSize.GetCrosshairSize(Radius));
    }
}

SetWeaponCrosshair()

void UCrosshairWidget::SetWeaponCrosshair ( const FCrosshairData & CrosshairType, const float Spread )

overridevirtual

{
    CrosshairData = CrosshairType;
    WeaponSpread = Spread;
    OnSetWeaponCrosshair(CrosshairType, Spread);
 
    if(CrosshairData.ReticleMaterial != nullptr)
    {
        OuterImage->SetBrushFromMaterial(CrosshairData.ReticleMaterial);
        OuterImageHorizontal->SetBrushFromMaterial(CrosshairData.ReticleMaterial);
    }
    if(CrosshairData.bUseSeparateHorizontalImage)
    {
        OuterImageHorizontal->SetVisibility(ESlateVisibility::HitTestInvisible);
    }
    else
    {
        OuterImageHorizontal->SetVisibility(ESlateVisibility::Collapsed);
    }
}

StartedAiming()

void UCrosshairWidget::StartedAiming ( )

overridevirtual

Implements ICrosshairInterface.

{
    bAiming = true;
    SetCrosshairOpacity();
    OnStartedAiming();
}

StoppedAiming()

void UCrosshairWidget::StoppedAiming ( )

overridevirtual

Implements ICrosshairInterface.

{
    bAiming = false;
    SetCrosshairOpacity();
    OnStoppedAiming();
}

VisibilityChangedEvent()

void UCrosshairWidget::VisibilityChangedEvent ( ESlateVisibility InVisibility )

protected

{
    switch (InVisibility)
    {
    case ESlateVisibility::Visible:
    case ESlateVisibility::HitTestInvisible:
    case ESlateVisibility::SelfHitTestInvisible:
        if(GetOwningPlayer() != nullptr)
        {
            if(!GetOwningPlayer()->GetWorldTimerManager().IsTimerActive(CrosshairUpdateTimerHandle))
            {
                GetOwningPlayer()->GetWorldTimerManager().SetTimer(CrosshairUpdateTimerHandle, this, &UCrosshairWidget::SetCrosshairLocation, UpdateSpeed, true);
            }
        }
        break;
    case ESlateVisibility::Collapsed:
    case ESlateVisibility::Hidden:
        if(GetOwningPlayer() != nullptr)
        {
            if(!GetOwningPlayer()->GetWorldTimerManager().IsTimerActive(CrosshairUpdateTimerHandle))
            {
                GetOwningPlayer()->GetWorldTimerManager().ClearTimer(CrosshairUpdateTimerHandle);
            }
        }
        break;
    default:
        break;
    }
}

Member Data Documentation

bAiming

bool UCrosshairWidget::bAiming = false

protected

bHolstered

bool UCrosshairWidget::bHolstered = true

protected

bRecoilFire

bool UCrosshairWidget::bRecoilFire = false

private

bShowDamageHitDot

bool UCrosshairWidget::bShowDamageHitDot = false

protected

bShowDamageNumbers

bool UCrosshairWidget::bShowDamageNumbers = false

protected

CrosshairData

FCrosshairData UCrosshairWidget::CrosshairData

protected

CrosshairOpacityLow

float UCrosshairWidget::CrosshairOpacityLow = 0.2f

protected

CrosshairOverlay

UWidget* UCrosshairWidget::CrosshairOverlay = nullptr

protected

Crosshairs

class UCircumferenceMarkerWidget* UCrosshairWidget::Crosshairs = nullptr

protected

CrosshairStyle

int32 UCrosshairWidget::CrosshairStyle = 0

protected

CrosshairUpdateTimerHandle

FTimerHandle UCrosshairWidget::CrosshairUpdateTimerHandle

private

DamageAmount

UTextBlock* UCrosshairWidget::DamageAmount = nullptr

protected

DamageVerticalBox

UWidget* UCrosshairWidget::DamageVerticalBox = nullptr

protected

HitMarkers

class UWidget* UCrosshairWidget::HitMarkers = nullptr

protected

HitMarkerTimerHandle

FTimerHandle UCrosshairWidget::HitMarkerTimerHandle

private

HitMarkerWidget

UWidget* UCrosshairWidget::HitMarkerWidget = nullptr

protected

InterpSpeed

float UCrosshairWidget::InterpSpeed = 12.0f

protected

LowerBound

float UCrosshairWidget::LowerBound = 25.0f

protected

OuterImage

class UImage* UCrosshairWidget::OuterImage = nullptr

protected

OuterImageHorizontal

class UImage* UCrosshairWidget::OuterImageHorizontal = nullptr

protected

PlayerSpeedMultiplier

float UCrosshairWidget::PlayerSpeedMultiplier = 0.15f

protected

Recoil

float UCrosshairWidget::Recoil

private

RecoilMultiplier

float UCrosshairWidget::RecoilMultiplier = 20.0f

protected

ReticleSizeBox

class USizeBox* UCrosshairWidget::ReticleSizeBox = nullptr

protected

UpdateSpeed

float UCrosshairWidget::UpdateSpeed = 0.03f

protected

UpperBound

float UCrosshairWidget::UpperBound = -80.0f

protected

WeaponSpread

float UCrosshairWidget::WeaponSpread = 0.0f

protected

WeaponSpreadMultiplier

float UCrosshairWidget::WeaponSpreadMultiplier = 0.15f

protected

---

The documentation for this class was generated from the following files:

• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/WeaponSystem/Source/WeaponSystem/Public/Widgets/CrosshairWidget.h
• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/WeaponSystem/Source/WeaponSystem/Private/Widgets/CrosshairWidget.cpp