#include <ComposableCameraTransitionBase.h>

Inherits: UObject Subclassed by: UComposableCameraCubicTransition, UComposableCameraCylindricalTransition, UComposableCameraDynamicDeocclusionTransition, UComposableCameraEaseTransition, UComposableCameraInertializedTransition, UComposableCameraLinearTransition, UComposableCameraPathGuidedTransition, UComposableCameraSmoothTransition, UComposableCameraSplineTransition, UComposableCameraViewTargetTransition

Base class for transition evaluation.

Transitions are pose-only operators: they receive source and target poses each tick, maintain their own internal blend state, and output a blended pose. They never reference cameras or Directors directly.

Public Attributes¶

OnTransitionFinishesDelegate¶

FOnTransitionFinishes OnTransitionFinishesDelegate

LastDebugSource¶

FTransitionDebugSnapshot LastDebugSource

LastDebugTarget¶

FTransitionDebugSnapshot LastDebugTarget

LastDebugBlended¶

FTransitionDebugSnapshot LastDebugBlended

Public Methods¶

Evaluate¶

FComposableCameraPose Evaluate(float DeltaTime, const FComposableCameraPose & CurrentSourcePose, const FComposableCameraPose & CurrentTargetPose)

Evaluate the transition for this frame, blending between source and target poses.

TransitionEnabled¶

void TransitionEnabled(const FComposableCameraTransitionInitParams & InInitParams)

Initialize the transition with source pose data. Called once before the first Evaluate.

TransitionFinished¶

void TransitionFinished()

Mark the transition as finished.

SetTransitionTime¶

void SetTransitionTime(float NewTransitionTime)

ResetTransitionState¶

void ResetTransitionState()

IsFinished¶

const inline

inline bool IsFinished() const

GetRemainingTime¶

const inline

inline float GetRemainingTime() const

GetTransitionTime¶

const inline

inline float GetTransitionTime() const

GetPercentage¶

const inline

inline float GetPercentage() const

GetBlendWeightAt¶

virtual const inline

virtual inline 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.).

DrawTransitionDebug¶

virtual const inline

virtual inline void DrawTransitionDebug(class 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.

Protected Attributes¶

TransitionTime¶

float TransitionTime

RemainingTime¶

float RemainingTime

bFinished¶

bool bFinished { false }

bFirstFrame¶

bool bFirstFrame { true }

InitParams¶

FComposableCameraTransitionInitParams InitParams

Percentage¶

float Percentage { 0.f }

InitialSourceRotation¶

FRotator InitialSourceRotation { FRotator::ZeroRotator }

Rotation captured from the source pose on the first evaluation frame.

InitialTargetRotation¶

FRotator InitialTargetRotation { FRotator::ZeroRotator }

Rotation captured from the target pose on the first evaluation frame.

InitialRotationDelta¶

FRotator InitialRotationDelta { FRotator::ZeroRotator }

Normalized first-frame source-to-target rotation delta.

PreviousSourceRotation¶

FRotator PreviousSourceRotation { FRotator::ZeroRotator }

Source rotation seen on the previous evaluation frame.

PreviousTargetRotation¶

FRotator PreviousTargetRotation { FRotator::ZeroRotator }

Target rotation seen on the previous evaluation frame.

AccumulatedSourceRotationOffset¶

FRotator AccumulatedSourceRotationOffset { FRotator::ZeroRotator }

Live source endpoint rotation offset accumulated after transition start.

AccumulatedTargetRotationOffset¶

FRotator AccumulatedTargetRotationOffset { FRotator::ZeroRotator }

Live target endpoint rotation offset accumulated after transition start.

bHasLockedRotationPathState¶

bool bHasLockedRotationPathState { false }

True once the locked rotation path state has been initialized.

TransitionClassTraceName¶

FString TransitionClassTraceName

Cached GetClass()->GetName() populated lazily at first Evaluate and reused by per-evaluate TRACE_CPUPROFILER_EVENT_SCOPE_STR so the dynamic Insights label doesn't allocate an FString per evaluation. The class is per-instance immutable after construction, so the lazy populate runs once over the transition's lifetime. Non-UPROPERTY because it's transient diagnostic state, not data.

Protected Methods¶

BlendPosesByLockedRotationPath¶

const

FComposableCameraPose BlendPosesByLockedRotationPath(const FComposableCameraPose & CurrentSourcePose, const FComposableCameraPose & CurrentTargetPose, float TargetWeight) const

Blend two poses while keeping the rotation path chosen when this transition started. Source and target poses are still evaluated live every frame. Any rotation movement that happens after the transition starts is accumulated as an endpoint offset and faded out/in by the same blend weight.

BlendRotationByLockedPath¶

const

FRotator BlendRotationByLockedPath(float TargetWeight) const

Evaluate only the locked rotation path plus live endpoint offsets.

ApplyLiveRotationOffsetsToBaseRotation¶

const

FRotator ApplyLiveRotationOffsetsToBaseRotation(const FRotator & BaseRotation, float TargetWeight) const

Apply live endpoint rotation offsets to a transition-specific base rotation.

GetInitialTargetRotation¶

const inline

inline const FRotator & GetInitialTargetRotation() const

Return the first-frame target rotation captured for the locked path.

OnBeginPlay¶

void OnBeginPlay(float DeltaTime, const FComposableCameraPose & CurrentSourcePose, const FComposableCameraPose & CurrentTargetPose)

Begin Play event. Called on the first frame of the transition, before the first OnEvaluate.
Use this to construct or initialize internal parameters specialized for this type of transition.

Parameters

• DeltaTime World delta time.
  

• CurrentSourcePose Current source camera pose.
  

• CurrentTargetPose Current target camera pose.
  

OnBeginPlay_Implementation¶

virtual inline

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

OnEvaluate¶

FComposableCameraPose OnEvaluate(float DeltaTime, const FComposableCameraPose & CurrentSourcePose, const FComposableCameraPose & CurrentTargetPose)

Event to customize the evaluation function for each tick. When calling this function, RemainingTime has already been decremented, and assured to not go below 0.

Parameters

• DeltaTime World delta time.
  

• CurrentSourcePose Current source camera pose.
  

• CurrentTargetPose Current target camera pose.
  

Returns

Returns the new blended camera pose.

OnEvaluate_Implementation¶

virtual inline

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

OnFinished¶

void OnFinished()

Event when the transition finishes. The base class simply sets bFinished to true.

DrawStandardTransitionDebug¶

const

void DrawStandardTransitionDebug(class UWorld * World, bool bViewerIsOutsideCamera, const FColor & AccentColor) const

Shared helper that paints the canonical source / target / progress endpoint markers. Each concrete transition's override still needs to draw its OWN path polyline (straight line, arc, polynomial, spline, rail, etc.) on top of these markers — the helper is deliberately silent about path shape because that's per-transition-type.

Always drawn (possessed play + F8 eject):

• Green sphere at LastDebugSource.Position (r = 15)

• Blue sphere at LastDebugTarget.Position (r = 15)

• AccentColor sphere at LastDebugBlended.Position (r = 20) — the actual camera position this frame. For non-linear transitions (Spline, Cylindrical, Inertialized, PathGuided) this will visibly sit off the straight source-to-target axis.

F8 / SIE only (drawn when bViewerIsOutsideCamera is true):

• Half-scale green frustum at the source pose.

• Half-scale blue frustum at the target pose.

Frustums are intentionally skipped in possessed play: the blended frustum is already drawn by the camera-level frustum path, and source/target frustums would pile up against the near plane.

AccentColor should be distinct from every node-gizmo color in the codebase (see Docs/TechDoc.md §3.20.4 for the reserved-color table).