#include <ComposableCameraCollisionPushNode.h>

Inherits: UComposableCameraCameraNodeBase

Node for resolving collision using self-spherical collision and trace collision.
This node does two things for collision:
(1) Casts a trace (either line or sphere) from camera to the target point and resolves any occlusion in-between;
(2) Carries a sphere around the camera and only resolves occlusion when the sphere collides with objects.
The first we call it TraceCollision, and the second SelfCollision, both dealt with collision channels.

Public Attributes¶

PivotActor¶

TObjectPtr< AActor > PivotActor

TraceCollisionChannel¶

TEnumAsByte< ETraceTypeQuery > TraceCollisionChannel

bTraceUseSphere¶

bool bTraceUseSphere { true }

TraceSphereRadius¶

double TraceSphereRadius { 12. }

TraceOcclusionExemptionTime¶

double TraceOcclusionExemptionTime { 0. }

SelfCollisionChannel¶

TEnumAsByte< ETraceTypeQuery > SelfCollisionChannel

SelfSphereRadius¶

double SelfSphereRadius { 12. }

SelfSphereDistanceOffsetFromCenter¶

double SelfSphereDistanceOffsetFromCenter { 10. }

ActorTypesToIgnore¶

TArray< TSoftClassPtr< AActor > > ActorTypesToIgnore

ExtraPushDistance¶

double ExtraPushDistance { 5. }

PushInterpolator¶

TObjectPtr< UComposableCameraInterpolatorBase > PushInterpolator

PullInterpolator¶

TObjectPtr< UComposableCameraInterpolatorBase > PullInterpolator

PivotZOffset¶

double PivotZOffset { 50. }

bUseBoneForDetection¶

bool bUseBoneForDetection { false }

BoneName¶

FName BoneName

Public Methods¶

UComposableCameraCollisionPushNode¶

inline

inline UComposableCameraCollisionPushNode()

OnInitialize_Implementation¶

virtual

virtual void OnInitialize_Implementation()

OnTickNode_Implementation¶

virtual

virtual void OnTickNode_Implementation(float DeltaTime, const FComposableCameraPose & CurrentCameraPose, FComposableCameraPose & OutCameraPose)

OnPreTick¶

virtual

virtual void OnPreTick(float DeltaTime, const FComposableCameraPose & CurrentCameraPose, FComposableCameraPose & OutCameraPose)

GetPinDeclarations_Implementation¶

virtual const

virtual void GetPinDeclarations_Implementation(TArray< FComposableCameraNodePinDeclaration > & OutPins) const

DrawNodeDebug¶

virtual const

virtual void DrawNodeDebug(UWorld * World, bool bViewerIsOutsideCamera) const

Called each frame when the CCS.Debug.Viewport CVar is enabled, for every node on the currently running camera. Override to draw world-space debug gizmos via DrawDebugHelpers (DrawDebugSphere, DrawDebugLine, etc.) that visualise this node's runtime state — e.g. a pivot sphere for PivotOffsetNode, a look-at line for LookAtNode, the collision trace for CollisionPushNode, a sampled spline path for SplineNode.

Access the owning camera via OwningCamera and current-frame pin values via the usual GetInputPinValue<T>() / member-read path — this hook fires AFTER TickNode, so pin-backed UPROPERTYs still hold the resolved values from the most recent evaluation.

bViewerIsOutsideCamera mirrors the ticker's frustum-draw flag: true when the viewer is observing the camera from outside (F8 eject, SIE, or CCS.Debug.Viewport.AlwaysShow), false when the player is looking through the camera. Most gizmos (pivot spheres at distant characters, lines to look-at targets, spline polylines far in the world) can ignore this and draw unconditionally. Gizmos that sit AT the camera's own position (e.g. CollisionPushNode's self-collision sphere) should gate on this bool so they don't hermetically seal the player inside the wireframe during live gameplay.

Default implementation does nothing. Compiled out in shipping builds.

Private Attributes¶

PushInterpolator_T¶

TUniquePtr< TCameraInterpolator< TValueTypeWrapper< double > > > PushInterpolator_T

PullInterpolator_T¶

TUniquePtr< TCameraInterpolator< TValueTypeWrapper< double > > > PullInterpolator_T

SkeletalMeshComponentForPivotActor¶

USkeletalMeshComponent * SkeletalMeshComponentForPivotActor { nullptr }

ElapsedExemptionTime¶

double ElapsedExemptionTime { 0. }

CurrentDistanceFromCamera¶

double CurrentDistanceFromCamera { 0. }

OriginalCameraPosition¶

FVector OriginalCameraPosition

LastTraceStart¶

FVector LastTraceStart { FVector::ZeroVector }

Cache populated in FindCollisionPoint each frame so DrawNodeDebug can repaint the trace + self-collision sphere without re-running the physics queries. All fields reset to ZeroVector / false each tick.

LastTraceEnd¶

FVector LastTraceEnd { FVector::ZeroVector }

LastTraceHitLocation¶

FVector LastTraceHitLocation { FVector::ZeroVector }

LastSelfSphereCenter¶

FVector LastSelfSphereCenter { FVector::ZeroVector }

bLastTraceBlocked¶

bool bLastTraceBlocked { false }

Private Methods¶

FindCollisionPoint¶

FComposableCameraHitResult FindCollisionPoint(double DeltaTime, const FVector & Start, const FVector & End, const FRotator & CameraRotation)

StartResolveCollision¶

FVector StartResolveCollision(double DeltaTime, const FVector & TargetLocation, const FVector & CameraPosition)

ResumeFromCollision¶

FVector ResumeFromCollision(double DeltaTime, const FVector & PivotPosition, const FVector & CameraPosition)