HitResult.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Chaos/PhysicsObject.h"
#include "Engine/NetSerialization.h"
#include "Engine/ActorInstanceHandle.h"
#include "HitResult.generated.h"
 
class AActor;
class UPackageMap;
class UPhysicalMaterial;
class UPrimitiveComponent;
 
USTRUCT(BlueprintType, meta = (HasNativeBreak = "/Script/Engine.GameplayStatics.BreakHitResult", HasNativeMake = "/Script/Engine.GameplayStatics.MakeHitResult"))
struct FHitResult
{
    GENERATED_BODY()
 
    
    UPROPERTY()
    int32 FaceIndex;
 
    UPROPERTY()
    float Time;
     
    UPROPERTY()
    float Distance;
    
    UPROPERTY()
    FVector_NetQuantize Location;
 
    UPROPERTY()
    FVector_NetQuantize ImpactPoint;
 
    UPROPERTY()
    FVector_NetQuantizeNormal Normal;
 
    UPROPERTY()
    FVector_NetQuantizeNormal ImpactNormal;
 
    UPROPERTY()
    FVector_NetQuantize TraceStart;
 
    UPROPERTY()
    FVector_NetQuantize TraceEnd;
 
    UPROPERTY()
    float PenetrationDepth;
 
    UPROPERTY(NotReplicated)
    int32 MyItem;
 
    UPROPERTY()
    int32 Item;
 
    UPROPERTY()
    uint8 ElementIndex;
 
    UPROPERTY()
    uint8 bBlockingHit : 1;
 
    UPROPERTY()
    uint8 bStartPenetrating : 1;
 
    UPROPERTY()
    TWeakObjectPtr<UPhysicalMaterial> PhysMaterial;
 
    UPROPERTY()
    FActorInstanceHandle HitObjectHandle;
 
    UPROPERTY()
    TWeakObjectPtr<UPrimitiveComponent> Component;
 
    TWeakObjectPtr<UObject> PhysicsObjectOwner;
 
    Chaos::FPhysicsObjectHandle PhysicsObject;
 
    UPROPERTY()
    FName BoneName;
 
    UPROPERTY(NotReplicated)
    FName MyBoneName;
 
 
    FHitResult()
    {
        Init();
    }
    
    explicit FHitResult(float InTime)
    {
        Init();
        Time = InTime;
    }
 
    explicit FHitResult(EForceInit InInit)
    {
        Init();
    }
 
    explicit FHitResult(ENoInit NoInit)
    {
    }
 
    explicit FHitResult(FVector Start, FVector End)
    {
        Init(Start, End);
    }
 
    inline void Init()
    {
        FMemory::Memzero(this, sizeof(FHitResult));
        HitObjectHandle = FActorInstanceHandle();
        Time = 1.f;
        MyItem = INDEX_NONE;
    }
 
    inline void Init(FVector Start, FVector End)
    {
        FMemory::Memzero(this, sizeof(FHitResult));
        HitObjectHandle = FActorInstanceHandle();
        Time = 1.f;
        TraceStart = Start;
        TraceEnd = End;
        MyItem = INDEX_NONE;
    }
 
    ENGINE_API FHitResult(AActor* InActor, UPrimitiveComponent* InComponent, FVector const& HitLoc, FVector const& HitNorm);
 
    inline void Reset(float InTime = 1.f, bool bPreserveTraceData = true)
    {
        const FVector SavedTraceStart = TraceStart;
        const FVector SavedTraceEnd = TraceEnd;
        Init();
        Time = InTime;
        if (bPreserveTraceData)
        {
            TraceStart = SavedTraceStart;
            TraceEnd = SavedTraceEnd;
        }
    }
 
    inline AActor* GetActor() const
    {
        return HitObjectHandle.FetchActor();
    }
 
    inline FActorInstanceHandle GetHitObjectHandle() const
    {
        return HitObjectHandle;
    }
 
    inline bool HasValidHitObjectHandle() const
    {
        return HitObjectHandle.IsValid();
    }
 
    inline UPrimitiveComponent* GetComponent() const
    {
        return Component.Get();
    }
 
    ENGINE_API bool NetSerialize(FArchive& Ar, UPackageMap* Map, bool& bOutSuccess);
 
    inline bool IsValidBlockingHit() const
    {
        return bBlockingHit && !bStartPenetrating;
    }
 
    static FHitResult* GetFirstBlockingHit(TArray<FHitResult>& InHits)
    {
        for(int32 HitIdx=0; HitIdx<InHits.Num(); HitIdx++)
        {
            if(InHits[HitIdx].bBlockingHit)
            {
                return &InHits[HitIdx];
            }
        }
        return nullptr;
    }
 
    static int32 GetNumBlockingHits(const TArray<FHitResult>& InHits)
    {
        int32 NumBlocks = 0;
        for(int32 HitIdx=0; HitIdx<InHits.Num(); HitIdx++)
        {
            if(InHits[HitIdx].bBlockingHit)
            {
                NumBlocks++;
            }
        }
        return NumBlocks;
    }
 
    static int32 GetNumOverlapHits(const TArray<FHitResult>& InHits)
    {
        return (InHits.Num() - GetNumBlockingHits(InHits));
    }
 
    static FHitResult GetReversedHit(const FHitResult& Hit)
    {
        FHitResult Result(Hit);
        Result.Normal = -Result.Normal;
        Result.ImpactNormal = -Result.ImpactNormal;
 
        int32 TempItem = Result.Item;
        Result.Item = Result.MyItem;
        Result.MyItem = TempItem;
 
        FName TempBoneName = Result.BoneName;
        Result.BoneName = Result.MyBoneName;
        Result.MyBoneName = TempBoneName;
        return Result;
    }
 
    ENGINE_API FString ToString() const;
};
 
// All members of FHitResult are PODs.
template<> struct TIsPODType<FHitResult> { enum { Value = true }; };
 
template<>
struct TStructOpsTypeTraits<FHitResult> : public TStructOpsTypeTraitsBase2<FHitResult>
{
    enum
    {
        WithNetSerializer = true,
    };
};