EShotAnchorMode¶

enum EShotAnchorMode

Selects how a Shot anchor — a single world-space point — is resolved from the Shot's targets. Used by both the placement anchor (where the camera is placed relative to) and the aim anchor (where the camera is looking at). See [FComposableCameraAnchorSpec](../structs/FComposableCameraAnchorSpec.md#fcomposablecameraanchorspec) below for the data-side.

EShotPlacementMode¶

enum EShotPlacementMode

Selects how the camera's POSITION is determined.

• AnchorOrbit: pure spherical placement around the placement anchor. Camera = PlacementAnchor + Distance · BasisQuat · UnitDir(Yaw, Pitch). ScreenPosition is unused — anchor projects to screen center under tentative look-at-anchor rotation. Recommended default; designers wanting an off-center anchor on screen should use Aim.ScreenPosition (rotation-realized) instead.

• AnchorAtScreen: AnchorOrbit's spherical placement THEN a lateral camera shift along basis-derived right / up axes to make the anchor project to Placement.ScreenPosition under tentative rotation. Useful for OTS-style framings where designer wants explicit control over the placement anchor's screen X / Y while Aim looks at a different anchor. Caveat: once the lateral shift is applied, the camera is no longer literally "at Yaw/Pitch around anchor" — the effective spherical position drifts. The two parametrizations (Yaw/Pitch + ScreenPosition) over-specify the camera position; the result is the geometric composition of both, NOT a strict spherical interpretation of Yaw/Pitch.

• FixedWorldPosition: camera placed at an explicit world-space point. No orbit, no anchor required for position. Useful for "locked" cinematic shots (cranes, jib heads, surveillance cams).

Drives the Placement layer of the Composition Solver. See Docs/ShotBasedKeyframing.md §4.3.

EShotAimMode¶

enum EShotAimMode

Selects how the camera's ROTATION is determined (after Position is set by the Placement layer).

• LookAtAnchor: camera rotates so the aim anchor lands at Aim.ScreenPosition. Closed-form via SolveCameraRotationForScreenTarget. The aim anchor may differ from the placement anchor — when it does, this is naturally an OTS / two-shot framing (camera placed near subject A, looking at subject B).

• NoOp: Aim layer does nothing. Output rotation = identity with Shot.Roll composed. Aim.AimAnchor and Aim.ScreenPosition are ignored. Useful when downstream nodes (or a FixedWorldPosition placement) should fully drive rotation; the editor renders the Aim handle greyed out as a non-effective indicator. Note: in NoOp mode SolvedFromBoundsFit FOV and FollowAnchor Focus modes still consume the identity rotation — projection / depth computations relative to that frame may not match designer intent; prefer Manual Lens + Focus modes when pairing with NoOp Aim.

Drives the Aim layer of the Composition Solver. See spec §4.4.

EShotFOVMode¶

enum EShotFOVMode

Selects how FOV is computed. Drives the Lens layer.

EShotFocusMode¶

enum EShotFocusMode

Selects what world point drives the focus distance. Independent of Position / Rotation / FOV. See spec §4.6.

EShotPlacementBasisFrame¶

enum EShotPlacementBasisFrame

Reference-frame selector for AnchorOrbit's LocalCameraDirection. Lives at [FShotPlacement::BasisFrame](../structs/FShotPlacement.md#basisframe). See spec §3.5.2.

EComposableCameraActorInputSource¶

enum EComposableCameraActorInputSource

Shared selector used by camera nodes that can either target an explicit actor or automatically follow the controller-controlled pawn.

EComposableCameraLockOnAimPointSource¶

enum EComposableCameraLockOnAimPointSource

EComposableCameraBuildStatus¶

enum EComposableCameraBuildStatus

Build status for camera type asset validation.

EComposableCameraActionExpirationType¶

enum EComposableCameraActionExpirationType

EComposableCameraActionExecutionType¶

enum EComposableCameraActionExecutionType

EComposableCameraResumeCameraTransformSchema¶

enum EComposableCameraResumeCameraTransformSchema

EShotTargetBoundsShape¶

enum EShotTargetBoundsShape

Selects how the bounding box around a shot target is determined. The bounding box drives the FOV solve when FOVMode == SolvedFromBoundsFit (Docs/ShotBasedKeyframing.md §4.5 — Weight-scaled Perceptual Union Box).

EBoundsCachePolicy¶

enum EBoundsCachePolicy

Cache refresh policy for AutoFromComponentBounds bounds shape. Only meaningful when BoundsShape == AutoFromComponentBounds.

EComposableCameraLookAtType¶

enum EComposableCameraLookAtType

EComposableCameraLookAtConstraintType¶

enum EComposableCameraLookAtConstraintType

EComposableCameraSpiralPivotSourceType¶

enum EComposableCameraSpiralPivotSourceType

Source of the pivot the spiral is built around.

FromActor — PivotActor->GetActorLocation() is sampled each frame. The actor's Up / Forward are also available as Spiral-Space axis sources. FromVector — PivotPosition is used directly. When this mode is active, RotationAxis = PivotActorUp and ReferenceDirection = PivotActorForward silently fall back to WorldUp / WorldX with a runtime warning — there is no actor to read from.

EComposableCameraSpiralRotationAxis¶

enum EComposableCameraSpiralRotationAxis

Axis around which the camera orbits. Defines Spiral Space's Up direction.

EComposableCameraSpiralReferenceDirection¶

enum EComposableCameraSpiralReferenceDirection

Direction that anchors θ = 0 in the plane perpendicular to the rotation axis. Defines Spiral Space's Forward direction after projection. The chosen direction is projected onto the plane perpendicular to the rotation axis and renormalized — it does not need to be pre-orthogonal to the axis.

CameraInitialForward captures the camera's forward vector on the first tick after activation and reuses it for the lifetime of the node, so the spiral starts seamlessly from the current camera orientation.

EComposableCameraSpiralPlayMode¶

enum EComposableCameraSpiralPlayMode

How the spiral evolves past Duration seconds. In every mode, θ / Radius / Height are direct curve evaluations at NormalizedTime — there is no per-frame integration and no accumulated state, so the pose at any arbitrary t is computable in O(1).

Once — NormalizedTime clamps at 1 after Duration; all three curves hold their Y at X=1. The pose freezes at the terminal frame. Loop — NormalizedTime = Fmod(Elapsed, Duration) / Duration. θ visually wraps cleanly when AngleCurve's Y(1) - Y(0) is a multiple of 360 (trig periodicity absorbs the jump); non-multiples snap at the cycle seam, which is the author's explicit choice. PingPong — NormalizedTime oscillates 0 → 1 → 0 → 1 every 2 * Duration seconds. All three curves are sampled at the mirrored time, so θ / Radius / Height naturally retrace on the return half. No sign flip needed — the X mirror alone carries the symmetry.

EComposableCameraSplineNodeSplineType¶

enum EComposableCameraSplineNodeSplineType

EComposableCameraSplineNodeMoveMethod¶

enum EComposableCameraSplineNodeMoveMethod

EComposableCameraPatchExpirationType¶

enum EComposableCameraPatchExpirationType

Bitmask of expiration channels that may individually fire to retire a Patch.

Mirrors the spirit of EComposableCameraActionExpirationType but is tailored to Patch's "always has an enter/exit envelope" model — there is no Instant variant because every Patch ramps in and out via its envelope.

A Patch's effective expiration is the OR of its enabled channels: the first channel to fire flips Phase to Exiting. Bits are independent and stack additively — e.g. (Duration | Manual) means "expires after Duration seconds OR when ExpirePatch is called, whichever comes first".

EComposableCameraPatchEase¶

enum EComposableCameraPatchEase

Easing curve applied symmetrically to the enter and exit alpha ramps.

Asset-only in V1 — there is no per-AddPatch override (an enum has no natural sentinel value, and adding a parallel bool is worse than asset-only). If a future case requires a runtime override, add a sixth Custom member with a companion FRuntimeFloatCurve pin (see PatchSystemProposal §8.1).

EComposableCameraPatchPhase¶

enum EComposableCameraPatchPhase

Lifecycle phase of a Patch instance.

Entering : alpha ramping 0 → 1 over EnterDuration. Patch evaluator already ticks at full fidelity. Active : alpha == 1, expiration channels are evaluated each frame. Exiting : alpha ramping 1 → 0 over ExitDuration. Expired : terminal; instance is removed at the end of PatchManager::Apply.

EComposableCameraImpulseBoxDistanceType¶

enum EComposableCameraImpulseBoxDistanceType

EComposableCameraPinDirection¶

enum EComposableCameraPinDirection

Direction of a camera node data pin.

EComposableCameraPinType¶

enum EComposableCameraPinType

Supported data types for camera node pins.

EComposableCameraExecEntryType¶

enum EComposableCameraExecEntryType

Tag for entries in the serialized execution chain.

The execution chain is a linear sequence of operations the camera runs each frame: camera nodes do the actual pose computation, and internal-variable Set operations write scratch values between camera nodes. See FComposableCameraExecEntry.

EComposableCameraTreeNodeKind¶

enum EComposableCameraTreeNodeKind

Runtime debug snapshot structures consumed by FComposableCameraDebugPanel.

These are distinct from the editor-side FComposableCameraDebugSnapshot (Core/ComposableCameraDebugSnapshot.h, WITH_EDITOR only). The editor one captures a SINGLE camera's per-node state for the Type Asset Editor's graph overlay. These structs capture the entire Tier-1 context stack + each context's Tier-2 evaluation tree, for the in-viewport debug panel (runtime, always available).

Design:

• Tree nodes are flattened DFS pre-order with a Depth field, so the renderer does not need recursion and can pick connector glyphs (vertical stem + elbow) from a single pass.

• All pointer data is resolved eagerly into display strings at snapshot time — consumers never deref anything runtime-owned. This makes the snapshot safe to cache and freeze.

• Progress / lifetime fields are captured as floats, not pre-formatted strings, so the renderer can draw real progress bars instead of parsing text. Kind of an evaluation-tree node. Parallels the TVariant in FComposableCameraEvaluationTreeNode.

EComposableCameraPatchSource¶

enum EComposableCameraPatchSource

Where a patch entry was sourced from — drives the row's prefix label so the designer can tell which path is producing each visible patch.

EComposableCameraAutoRotateDirectionMode¶

enum EComposableCameraAutoRotateDirectionMode

EComposableCameraNodeLevelSequenceCompatibility¶

enum EComposableCameraNodeLevelSequenceCompatibility

How a node class behaves when evaluated in a Level-Sequence context, where the camera is driven by a UComposableCameraLevelSequenceComponent and no UComposableCameraPlayerCameraManager is present.

Queried by the LS Details-panel customization (to warn the designer) and by the LS component's tick path (to decide whether to evaluate the node at all).

Default is Compatible; override in node classes that cannot run without a PCM, or on compute-chain nodes that are never evaluated in LS by design.

EComposableCameraNodePatchCompatibility¶

enum EComposableCameraNodePatchCompatibility

Declares how a node behaves when placed in a Camera Patch graph (per PatchSystemProposal §11). A Patch evaluator receives an upstream pose each frame and expects its nodes to read-modify-write that pose — nodes that synthesize pose from scratch or delegate to external sources produce surprising results in a Patch context.

Queried by the Patch asset's editor-time validation (to warn the designer via Build messages) and by future runtime tooling (no current runtime gate, so Incompatible nodes do run — they just produce wrong output). The classification is authoring-side guidance, not a runtime safety net.

Default is Compatible; override in nodes that have surprising semantics.

ECameraPivotOffset¶

enum ECameraPivotOffset

EComposableCameraMixingCameraWeightNormalizationMethod¶

enum EComposableCameraMixingCameraWeightNormalizationMethod

Weight normalization method.

EComposableCameraMixingCameraMode¶

enum EComposableCameraMixingCameraMode

Mixing camera node mode.

EComposableCameraMixingCameraRotationMethod¶

enum EComposableCameraMixingCameraRotationMethod

Different methods to average rotations. Ref: https://sulley.cc/2024/01/11/20/06/.

EComposableCameraSplineTransitionType¶

enum EComposableCameraSplineTransitionType

EComposableCameraSplineTransitionEvaluationCurveType¶

enum EComposableCameraSplineTransitionEvaluationCurveType

EComposableCameraHitchcockZoomDriver¶

enum EComposableCameraHitchcockZoomDriver

Which authored quantity the node drives. The other is solved from the frame-zero lock constant.

FromFOVDelta — author FOVDeltaCurve, derive camera distance. Natural when you think about the look of the effect ("background should distort to N degrees wider"). FromDistanceDelta — author DistanceDeltaCurve, derive FOV. Natural when you think about the physical move ("camera dollies back 3 metres").

Both paths preserve the same distance · tan(FOV/2) = LockConstant invariant captured on the first tick, so the two authoring styles are physically equivalent — the choice is purely about which curve is easier to shape in the project's authoring pipeline.

EComposableCameraRotationConstrainType¶

enum EComposableCameraRotationConstrainType

EComposableCameraSetRotationSource¶

enum EComposableCameraSetRotationSource

EComposableCameraScreenSpaceMethod¶

enum EComposableCameraScreenSpaceMethod

EComposableCameraScreenSpacePivotSource¶

enum EComposableCameraScreenSpacePivotSource

EComposableCameraVolumeSource¶

enum EComposableCameraVolumeSource

How the constraint volume is sourced.

FromActor — Pull the shape from the first UShapeComponent on VolumeActor. UBoxComponent and USphereComponent are supported; the component's world transform + scaled extents drive the volume. Capsule and other shape subclasses are rejected with a warning. Inline — The node carries its own world-space volume definition via VolumeCenter / VolumeRotation / BoxExtents / SphereRadius.

EComposableCameraVolumeShape¶

enum EComposableCameraVolumeShape

Shape of the constraint volume in Inline mode. FromActor mode resolves the shape from the component's concrete class.

EComposableCameraPathGuidedTransitionType¶

enum EComposableCameraPathGuidedTransitionType

EComposableCameraShotSource¶

enum EComposableCameraShotSource

Source-of-truth for a Shot Section's framing data — Inline value-typed struct or AssetReference soft-pointer. See [UComposableCameraShotAsset](../uobjects-other/UComposableCameraShotAsset.md#ucomposablecamerashotasset) and spec §3.4.1.

EComposableCameraRelativeFixedPoseMethod¶

enum EComposableCameraRelativeFixedPoseMethod