#include <ComposableCameraCylindricalTransition.h>

Inherits: UComposableCameraTransitionBase

Cylindrical transition.

Public Attributes

Return Name Description
float MinimumDistanceFromOrigin
bool bLockToPivot

MinimumDistanceFromOrigin

float MinimumDistanceFromOrigin { 10.f }

bLockToPivot

bool bLockToPivot { true }

Public Methods

Return Name Description
void OnBeginPlay_Implementation virtual
FComposableCameraPose OnEvaluate_Implementation virtual
float GetBlendWeightAt virtual 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.
void DrawTransitionDebug virtual const Per-transition world-space debug hook.

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


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.