WorldCollision.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
// Structs that are used for Async Trace functionality
// Mostly used by a batch of traces that you don't need a result right away
 
#pragma once 
 
#include "Async/TaskGraphFwd.h"
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_4
#include "CoreMinimal.h"
#endif // UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_4
#include "CollisionQueryParams.h"
#include "CollisionShape.h"
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_4
#include "Engine/OverlapResult.h"
#include "Engine/HitResult.h"
#endif // UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_4
 
struct FOverlapDatum;
struct FTraceDatum;
struct FHitResult;
struct FOverlapResult;
typedef TArray<FGraphEventRef, TInlineAllocator<4> > FGraphEventArray;
 
struct FTraceHandle
{
    union
    {
        uint64  _Handle;
        struct  
        {
            uint32 FrameNumber;
            uint32 Index;
        } _Data;
    };
    bool bTransactional = false;
 
    FTraceHandle() : _Handle(0) {};
    FTraceHandle(uint32 InFrameNumber, uint32 InIndex, bool bInTransactional = false)
    {
        _Data.FrameNumber = InFrameNumber;
        _Data.Index = InIndex;
        bTransactional = bInTransactional;
    }
 
    friend inline uint32 GetTypeHash(const FTraceHandle& Handle)
    {
        return GetTypeHash(Handle._Handle);
    }
 
    bool operator==(FTraceHandle const& Other) const
    {
        return Other._Handle == _Handle;
    }
 
    bool operator!=(FTraceHandle const& Other) const
    {
        return Other._Handle != _Handle;
    }
 
    bool IsValid() const
    {
        return _Handle != 0;
    }
 
    void Invalidate()
    {
        _Handle = 0;
    }
 
    bool IsTransactional() const
    {
        return bTransactional;
    }
};
 
struct FCollisionParameters
{
    struct FCollisionQueryParams        CollisionQueryParam;
    struct FCollisionResponseParams     ResponseParam;
    struct FCollisionObjectQueryParams  ObjectQueryParam;
 
    struct FCollisionShape CollisionShape;
 
    FCollisionParameters()
        : CollisionQueryParam(NAME_None, TStatId())
    {
    }
};
 
struct FBaseTraceDatum
{
    TWeakObjectPtr<UWorld> PhysWorld;
 
    FCollisionParameters    CollisionParams;
 
    ECollisionChannel TraceChannel;
 
    uint32  FrameNumber; 
 
    uint32  UserData;
 
    FBaseTraceDatum() {};
 
    void Set(UWorld * World, const FCollisionShape& InCollisionShape, const FCollisionQueryParams& Param, const struct FCollisionResponseParams &InResponseParam, const struct FCollisionObjectQueryParams& InObjectQueryParam, 
        ECollisionChannel Channel, uint32 InUserData, int32 FrameCounter);
};
 
struct FTraceDatum;
struct FOverlapDatum;
 
DECLARE_DELEGATE_TwoParams( FTraceDelegate, const FTraceHandle&, FTraceDatum &);
DECLARE_DELEGATE_TwoParams( FOverlapDelegate, const FTraceHandle&, FOverlapDatum &);
 
enum class EAsyncTraceType : uint8
{
    Test,
    Single,
    Multi
};
 
struct FTraceDatum : public FBaseTraceDatum
{
    FVector Start;
    FVector End;
    FQuat   Rot;
    FTraceDelegate Delegate;
 
    TArray<struct FHitResult> OutHits;
 
    EAsyncTraceType TraceType;
 
    ENGINE_API FTraceDatum();
 
    ENGINE_API FTraceDatum(UWorld* World, const FCollisionShape& CollisionShape, const FCollisionQueryParams& Param, const struct FCollisionResponseParams& InResponseParam, const struct FCollisionObjectQueryParams& InObjectQueryParam,
        ECollisionChannel Channel, uint32 InUserData, EAsyncTraceType InTraceType, const FVector& InStart, const FVector& InEnd, const FQuat& InRot, const FTraceDelegate* InDelegate, int32 FrameCounter);
};
 
struct FOverlapDatum : FBaseTraceDatum
{
    FVector Pos;
    FQuat   Rot;
    FOverlapDelegate Delegate;
 
    TArray<struct FOverlapResult> OutOverlaps;
 
    ENGINE_API FOverlapDatum();
 
    ENGINE_API FOverlapDatum(UWorld * World, const FCollisionShape& CollisionShape, const FCollisionQueryParams& Param, const struct FCollisionResponseParams &InResponseParam, const struct FCollisionObjectQueryParams& InObjectQueryParam, 
                  ECollisionChannel Channel, uint32 InUserData,
                  const FVector& InPos, const FQuat& InRot, const FOverlapDelegate* InDelegate, int32 FrameCounter);
};
 
#define ASYNC_TRACE_BUFFER_SIZE 64
 
template <typename T>
struct TTraceThreadData
{
    T Buffer[ASYNC_TRACE_BUFFER_SIZE];
};
 
template <typename DatumType>
struct FTransactionalAsyncTraceBuffer
{
    TArray<TUniquePtr<TTraceThreadData<DatumType>>> Data;
    int32 NumQueued;
};
 
struct AsyncTraceData : FNoncopyable
{
    TArray<TUniquePtr<TTraceThreadData<FTraceDatum>>>           TraceData;
    TArray<TUniquePtr<TTraceThreadData<FOverlapDatum>>>         OverlapData;
 
    int32 NumQueuedTraceData;
    int32 NumQueuedOverlapData;
 
    FTransactionalAsyncTraceBuffer<FTraceDatum> TransactionalTraceData;
    FTransactionalAsyncTraceBuffer<FOverlapDatum> TransactionalOverlapData;
 
    bool                    bAsyncAllowed; 
 
    bool                    bAsyncTasksCompleted;
 
    FGraphEventArray        AsyncTraceCompletionEvent;
 
    ENGINE_API AsyncTraceData();
    ENGINE_API ~AsyncTraceData();
};
 
 
extern ECollisionChannel DefaultCollisionChannel;
ENGINE_API DECLARE_LOG_CATEGORY_EXTERN(LogCollision, Warning, All);