#include <ComposableCameraPathGuidedTransition.h>

Inherits: UComposableCameraTransitionBase

A transition which utilizes a path　(spline) to guide its position during transition. This transition leverages two InertializedTransitions to achieve smoothness. An intermediate camera will be spawned as a wrapper for the spline. So this transition will be more expensive than other transitions.

Public Attributes¶

DrivingTransition¶

TObjectPtr< UComposableCameraTransitionBase > DrivingTransition

Type¶

EComposableCameraPathGuidedTransitionType Type {  }

RailActor¶

TSoftObjectPtr< ACameraRig_Rail > RailActor

GuideRange¶

FVector2D GuideRange { 0.25, 0.75 }

SplineMoveCurve¶

TObjectPtr< UCurveFloat > SplineMoveCurve

Public Methods¶

OnBeginPlay_Implementation¶

virtual

virtual void OnBeginPlay_Implementation(float DeltaTime, const FComposableCameraPose & CurrentSourcePose, const FComposableCameraPose & CurrentTargetPose)

OnEvaluate_Implementation¶

virtual

virtual FComposableCameraPose OnEvaluate_Implementation(float DeltaTime, const FComposableCameraPose & CurrentSourcePose, const FComposableCameraPose & CurrentTargetPose)

GetBlendWeightAt¶

virtual const

virtual float GetBlendWeightAt(float NormalizedTime) const

Evaluate the transition's timing curve at a given normalized progress in [0, 1]. Returns the blend weight this transition would apply at that progress — i.e. the shape of its Percentage-over-duration curve.

Used exclusively by the debug panel to render a sparkline preview of the blend curve on top of the transition's progress bar. The call site is a one-per-frame-per-active-transition sample loop, so the implementation must stay cheap (no allocations, no state reads that mutate). NOT used on the runtime evaluation hot path — real blend weight is still derived from Percentage in OnEvaluate so that per-transition state (polynomials, curves, etc.) keeps driving it.

Default implementation returns the input unchanged, giving a linear diagonal — the right fallback for transitions whose concept of "blend weight" isn't a simple scalar of normalized time (Inertialized position path, for example, is a polynomial trajectory, not a scalar lerp; showing a diagonal there still reads as "progress = time" which is accurate for its rotational / overall progression).

Concrete overrides should be pure math — no reads of RemainingTime, TransitionTime, or any internal state. Use only the NormalizedTime argument plus the transition's authored UPROPERTYs (Exp, bSmootherStep, EvaluationCurveType, etc.).

BeginDestroy¶

virtual

virtual void BeginDestroy()

DrawTransitionDebug¶

virtual const

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

Per-transition world-space debug hook.

Invoked from [UComposableCameraEvaluationTree::DrawTransitionsDebug](../core/UComposableCameraEvaluationTree.md#drawtransitionsdebug) while CCS.Debug.Viewport is on, once per frame for every transition that currently sits in an Inner node of the active director's tree (and, recursively, of any referenced director's tree — inter-context blends see both sides).

Default implementation is empty. Concrete transitions override, check their own CCS.Debug.Viewport.Transitions.<Name> CVar, and usually call DrawStandardTransitionDebug plus any type-specific extras (spline curve sample, feeler rays, etc.).

Parameters

• World World to draw into. Routes through the world's LineBatcher, so the draw is visible in every viewport that renders this world (game + F8-ejected editor).

• bViewerIsOutsideCamera True when the player is NOT viewing through the camera (F8 eject / SIE). Overrides use this to skip gizmos that would occlude the near plane — mostly the source/target frustum pyramids.

Compiled out in shipping builds.

Private Attributes¶

IntermediateCamera¶

TObjectPtr< AComposableCameraCameraBase > IntermediateCamera { nullptr }

Rail¶

TObjectPtr< ACameraRig_Rail > Rail { nullptr }

EnterTransition¶

TObjectPtr< UComposableCameraInertializedTransition > EnterTransition { nullptr }

ExitTransition¶

TObjectPtr< UComposableCameraInertializedTransition > ExitTransition { nullptr }

InternalSpline¶

TObjectPtr< USplineComponent > InternalSpline { nullptr }

DebugSplineActor¶

TObjectPtr< AActor > DebugSplineActor { nullptr }

Private Methods¶

ResolveAndValidateRail¶

bool ResolveAndValidateRail()

DestroySpawnedActors¶

void DestroySpawnedActors()

BuildInternalSpline¶

bool BuildInternalSpline(const FComposableCameraPose & CurrentTargetPose, float DeltaTime)

Returns true on success, false if any spawn / duplicate step returned null (caller should DestroySpawnedActors and degrade to a hard cut).