reacthub-pixitweenjs 0.3.2-alpha.0 → 0.3.3

package/dist/components/AepComposition/AepComposition.d.ts

@@ -1,3 +1,4 @@
+import { StageLayoutListener } from './stage3d/AepStageLayoutContext';
 import { AepCompositionJson, AepThemeMap, AepTransitionOverrideMap } from '../../types/aep';
 import { AepTextOverrideMap } from './AepTextOverrideContext';
 import { AepAssetOverrideMap } from './AepLayerProvider';
@@ -15,5 +16,6 @@ export interface AepCompositionProps {
     transitionOverrides?: AepTransitionOverrideMap;
     onRenderReady?: () => void;
     onLayerError?: (layerId: string, error: unknown) => void;
+    onStageLayout?: StageLayoutListener;
 }
 export declare const AepComposition: React.FC<AepCompositionProps>;

package/dist/components/AepComposition/index.d.ts

@@ -38,7 +38,7 @@ export type { Transform3DChannels } from './composeTransform3D';
 export { useAepLayerTransform } from './useAepLayerTransform';
 export type { AepResolvedTransform } from './useAepLayerTransform';
 export { AepAssetResolverProvider, defaultAssetResolver, useAepAssetResolver, type AepAssetResolver, type AepResolvedAsset, } from './AepAssetResolver';
-export { useResolveAsset } from './useResolveAsset';
+export { useResolveAsset, useResolveAssets } from './useResolveAsset';
 export type { AepAssetState, AepResolvedAssetState } from './useResolveAsset';
 export { AepThemeProvider, useAepTheme, mergeTheme, } from './AepThemeContext';
 export { AepTextOverrideProvider, useAepTextOverride, resolveTextSource, } from './AepTextOverrideContext';
@@ -48,3 +48,4 @@ export { shouldSplitText } from './shouldSplitText';
 export { AudioPlaybackManager } from './AudioPlaybackManager';
 export type { AudioPlaybackManagerProps, AudioPlaybackElement, } from './AudioPlaybackManager';
 export * from './model3d';
+export * from './stage3d';

package/dist/components/AepComposition/model3d/animation.d.ts

@@ -0,0 +1,21 @@
+import { AepModel3DAnimation } from '../../../types/aep';
+export interface NamedClip {
+    name: string;
+    duration: number;
+}
+/**
+ * Picks the clip an `animation.clip` selector refers to. A name or index that
+ * does not exist falls back to clip 0 (`fellBack` is set so callers can warn).
+ */
+export declare function pickClip<T extends NamedClip>(clips: readonly T[], selector: AepModel3DAnimation["clip"]): {
+    clip: T;
+    fellBack: boolean;
+} | null;
+export declare const HOLD_EPSILON = 0.0001;
+/**
+ * Seconds to scrub the mixer to: `offset + speed * (time since in-point)`.
+ * With `loop: false` the time holds just before `clipDuration`. Holding here
+ * instead of using THREE.LoopOnce keeps seeking stateless: a LoopOnce action
+ * pauses itself at the end and then ignores `mixer.setTime` on a seek back.
+ */
+export declare function animationTimeSeconds(frame: number, inPointFrames: number, fps: number, animation?: AepModel3DAnimation, clipDuration?: number): number;

package/dist/components/AepComposition/model3d/index.d.ts

@@ -6,6 +6,8 @@ export { ThreeOffscreenRenderer, acquireOffscreenRenderer, releaseOffscreenRende
 export type { OffscreenRenderRequest, OffscreenGlRenderer, } from './ThreeOffscreenRenderer';
 export { frameCamera, clipTimeSeconds, isFrameInRange } from './framing';
 export type { CameraFraming } from './framing';
+export { animationTimeSeconds, pickClip } from './animation';
+export { applyToonStyle, getToonGradientMap } from './toon';
 export { LIGHTING_PRESETS, DEFAULT_LIGHTING_PRESET, resolveLightingConfig, directionFromAzimuthElevation, } from './lighting';
 export type { LightingConfig, LightingOverrides, LightingPresetName, LightingRig, } from './lighting';
 export { buildPrimitiveGeometry, buildExtrudeGeometry, buildSourceGeometry, } from './geometry';

package/dist/components/AepComposition/model3d/threeUtils.d.ts

@@ -0,0 +1,15 @@
+import * as THREE from "three";
+export declare function makeMaterial(color: string, map: THREE.Texture | null, clearcoat: number, centerOnFront?: boolean): THREE.MeshPhysicalMaterial;
+export declare function loadTexture(url: string): Promise<THREE.Texture>;
+export declare function collectMaterials(root: THREE.Object3D): THREE.MeshStandardMaterial[];
+/** Textures flagged `userData.shared` (e.g. the cached toon gradient) outlive any one object. */
+export declare function isSharedTexture(texture: THREE.Texture): boolean;
+export interface DisposeOptions {
+    /**
+     * Dispose only resources flagged `userData.stageOwned`. A stage3d member shares
+     * geometries, materials and textures with its cached glTF (clones reference
+     * them), so it frees only what it created itself.
+     */
+    onlyOwned?: boolean;
+}
+export declare function disposeObject3D(root: THREE.Object3D, options?: DisposeOptions): void;

package/dist/components/AepComposition/model3d/toon.d.ts

@@ -0,0 +1,26 @@
+import * as THREE from "three";
+/** N-band 1px-high ramp for MeshToonMaterial.gradientMap (nearest-filtered, so bands stay hard). */
+export declare function getToonGradientMap(steps: number): THREE.DataTexture;
+export declare function createOutlineMaterial(color: string, width: number): THREE.MeshBasicMaterial;
+/**
+ * Hull geometry with position-welded, smoothed normals. Hard-edged meshes (boxes) carry per-face
+ * normals, which would pull an inflated hull apart at every edge and leave gaps in the outline.
+ */
+export declare function createSmoothedHullGeometry(source: THREE.BufferGeometry): THREE.BufferGeometry;
+export interface ToonStyleOptions {
+    toon: boolean;
+    steps: number;
+    outline?: {
+        color: string;
+        width: number;
+    };
+}
+/**
+ * Applies the cartoon look to `content` in place. Returns the replaced
+ * (original) materials so the caller can dispose them. Outline hulls are
+ * children of their mesh, so disposing `content` disposes them too.
+ */
+export declare function applyToonStyle(content: THREE.Object3D, options: ToonStyleOptions): {
+    replaced: THREE.Material[];
+    hulls: THREE.Mesh[];
+};

package/dist/components/AepComposition/stage3d/AepStageLayoutContext.d.ts

@@ -0,0 +1,21 @@
+import { StageRect } from './layout';
+import * as React from "react";
+export interface StageLayoutEvent {
+    worldId: string;
+    frame: number;
+    /** The world layer's offscreen size; rects are in these pixels. Map to comp px with the layer's own transform. */
+    viewport: {
+        width: number;
+        height: number;
+    };
+    rects: Record<string, StageRect & {
+        role?: "prop" | "product";
+    }>;
+}
+export type StageLayoutListener = (event: StageLayoutEvent) => void;
+export declare const AepStageLayoutProvider: React.FC<{
+    onStageLayout?: StageLayoutListener;
+    children: React.ReactNode;
+}>;
+/** Null when nobody listens, so the layer can skip the projection work. */
+export declare function useAepStageLayoutListener(): StageLayoutListener | null;

package/dist/components/AepComposition/stage3d/Pixi3DStageLayer.d.ts

@@ -0,0 +1,11 @@
+import { ForwardedRefResponse, PixiBaseSpriteProps } from '../../../types/BaseProps';
+import { AepStage3DLayer, AepStageMemberLayer } from '../../../types/aep';
+import * as React from "react";
+export interface Pixi3DStageLayerProps extends PixiBaseSpriteProps {
+    layer: AepStage3DLayer;
+}
+/** Members of this world, in composition order. In a precomp, `layersById` is the precomp's own list. */
+export declare function useStageMembers(worldId: string): AepStageMemberLayer[];
+export declare const Pixi3DStageLayer: React.MemoExoticComponent<({ ref, layer, ...props }: Pixi3DStageLayerProps & {
+    ref?: React.Ref<ForwardedRefResponse | null>;
+}) => React.JSX.Element>;

package/dist/components/AepComposition/stage3d/StageRuntime.d.ts

@@ -0,0 +1,66 @@
+import { GLTF } from 'three/examples/jsm/loaders/GLTFLoader.js';
+import { AepStage3DLayer, AepStageMemberLayer } from '../../../types/aep';
+import { StageWorld } from './buildWorld';
+import { StageMemberRig } from './members/types';
+import { SampledStageWorld } from './sampleStage3D';
+import * as THREE from "three";
+export interface ReconcileInput {
+    worldLayer: AepStage3DLayer;
+    /** Changes when the world itself must be rebuilt (viewport, camera, set, style, spots, backdrop URL). */
+    worldKey: string;
+    members: Array<{
+        layer: AepStageMemberLayer;
+        key: string;
+        attachTo?: string;
+    }>;
+    /** assetId -> URL */
+    urls: Readonly<Record<string, string>>;
+}
+export interface StageRuntimeOptions {
+    renderer?: () => THREE.WebGLRenderer | undefined;
+    loadGltf?: (url: string) => Promise<GLTF>;
+    loadTexture?: (url: string) => Promise<THREE.Texture>;
+    warn?: (message: string) => void;
+    onError?: (error: unknown) => void;
+}
+interface BuiltMember {
+    rig: StageMemberRig;
+    layer: AepStageMemberLayer;
+}
+export declare class StageRuntime {
+    private readonly options;
+    world: StageWorld | null;
+    /** True once the latest reconcile finished: the world and every member are built. */
+    ready: boolean;
+    readonly rigs: Map<string, BuiltMember>;
+    private state;
+    private gen;
+    private disposed;
+    /** Set whenever something was built: the next apply renders once with everything visible. */
+    private needsWarm;
+    private queue;
+    private readonly gltfCache;
+    private readonly warned;
+    constructor(options?: StageRuntimeOptions);
+    private loadGltf;
+    private warn;
+    /** Resolves true when this call's input is fully built, false if superseded, disposed or failed. */
+    reconcile(input: ReconcileInput): Promise<boolean>;
+    private stale;
+    private run;
+    /** Applies the sampled world + member poses. No-op until ready. */
+    apply(world: SampledStageWorld, samples: ReadonlyMap<string, unknown>): boolean;
+    /**
+     * Renders once with every member visible. Three compiles shaders and uploads
+     * geometry, skeleton textures and shadow maps on first use, and skips invisible
+     * objects, so without this a member that enters later (inPoint) or is un-hidden
+     * costs a one-off hitch mid-playback. The real draw follows immediately and
+     * overwrites the output.
+     */
+    private warm;
+    private disposeMember;
+    private disposeBuilt;
+    /** Frees members, world and the glTF cache. Safe to call twice. */
+    dispose(): Promise<void>;
+}
+export {};

package/dist/components/AepComposition/stage3d/buildWorld.d.ts

@@ -0,0 +1,52 @@
+import { AepStage3DLayer } from '../../../types/aep';
+import { LightingRig } from '../model3d/lighting';
+import { SampledStageWorld } from './sampleStage3D';
+import * as THREE from "three";
+export interface StageWorld {
+    scene: THREE.Scene;
+    camera: THREE.PerspectiveCamera;
+    lighting: LightingRig;
+    spots: Map<string, {
+        light: THREE.SpotLight;
+        target: THREE.Object3D;
+    }>;
+    ground: THREE.Mesh;
+    wall: THREE.Mesh | null;
+    /** True when the wall carries the unlit backdrop image (it must not be toon-shaded). */
+    hasBackdrop: boolean;
+    membersRoot: THREE.Group;
+    extents: {
+        halfWidth: number;
+        halfDepth: number;
+    };
+    dispose(): void;
+}
+export interface CycloramaOptions {
+    width: number;
+    distance: number;
+    height: number;
+    curve: number;
+    /** v = 0 across the cove and 0->1 up the vertical wall (for a painted backdrop). */
+    wallUv?: boolean;
+}
+/**
+ * Curved studio wall in the YZ plane, extruded along X: a quarter-circle cove of
+ * radius `curve` blends the floor (starting at z = -distance + curve) into a
+ * vertical wall at z = -distance, up to `height`. Normals face +Z / up.
+ */
+export declare function buildCycloramaGeometry({ width, distance, height, curve, wallUv, }: CycloramaOptions): THREE.BufferGeometry;
+export declare function lightingConfigFor(s: SampledStageWorld["lighting"]): {
+    ambientIntensity: number;
+    preset: import('..').LightingPresetName;
+    keyAzimuth: number;
+    keyElevation: number;
+    keyIntensity: number;
+    keyColor: string;
+    fillIntensity: number;
+    rimIntensity: number;
+    environmentIntensity: number;
+    environment: "room" | "none";
+};
+export declare function buildWorld(world: AepStage3DLayer, backdrop: THREE.Texture | null, renderer?: THREE.WebGLRenderer): StageWorld;
+/** Per-frame world values: lights, ambient, spots, shadow strength. No allocation of GPU resources. */
+export declare function applyWorld(w: StageWorld, s: SampledStageWorld, renderer?: THREE.WebGLRenderer): void;

package/dist/components/AepComposition/stage3d/clipBinding.d.ts

@@ -0,0 +1,29 @@
+import * as THREE from "three";
+/** `mixamorig:LeftArm`, `mixamorigLeftArm`, `mixamorig1:LeftArm`, `LeftArm` -> `leftarm`. */
+export declare function normalizeBoneName(name: string): string;
+export interface BindResult {
+    /** clip track name -> rewritten track name for the actor */
+    trackMap: Map<string, string>;
+    /** normalised clip bones with no match in the actor (sorted, unique) */
+    missingBones: string[];
+    boundBones: number;
+}
+export declare function splitTrackName(trackName: string): {
+    node: string;
+    property: string;
+} | null;
+export declare function bindTrackNames(trackNames: readonly string[], actorBoneNames: readonly string[]): BindResult;
+export interface BindOptions {
+    rootMotion: "strip" | "keep";
+    /** Multiplies hips position values (clip units -> actor units). */
+    hipsScale: number;
+}
+/**
+ * Hips scale for converting a clip authored in another unit (Mixamo cm vs a
+ * metre actor): actor hips rest height / clip hips first height.
+ */
+export declare function computeHipsScale(clip: THREE.AnimationClip, actorRoot: THREE.Object3D): number;
+export declare function bindClipToSkeleton(clip: THREE.AnimationClip, actorRoot: THREE.Object3D, opts: BindOptions): {
+    clip: THREE.AnimationClip;
+    missingBones: string[];
+};

package/dist/components/AepComposition/stage3d/convert.d.ts

@@ -0,0 +1,9 @@
+import { AepModel3DLayer, AepProp3DLayer } from '../../../types/aep';
+/**
+ * Upgrade path from the standalone `model3d` fallback: turns its product into a
+ * `prop3d` member of the world `stageId`. Copies identity, range, source and
+ * textures; `view.rotation` keyframes become the prop's `rotation`. Lighting,
+ * shadow, viewport and camera belong to the world (build it once per shot) and
+ * are not copied.
+ */
+export declare function model3dToProp3d(layer: AepModel3DLayer, stageId: string): AepProp3DLayer;

package/dist/components/AepComposition/stage3d/index.d.ts

@@ -0,0 +1,14 @@
+export { Pixi3DStageLayer, useStageMembers } from './Pixi3DStageLayer';
+export type { Pixi3DStageLayerProps } from './Pixi3DStageLayer';
+export { sampleStageWorld, sampleActor3D, sampleProp3D, memberActive, scheduleClips, clipLocalTime, stageFrameKey, } from './sampleStage3D';
+export type { SampledStageWorld, SampledActor3D, SampledProp3D, SampledClipWeight, } from './sampleStage3D';
+export { normalizeBoneName, bindTrackNames, bindClipToSkeleton } from './clipBinding';
+export { buildCycloramaGeometry } from './buildWorld';
+export { planReconcile } from './reconcile';
+export { projectBoxToViewport } from './layout';
+export { model3dToProp3d } from './convert';
+export type { StageRect } from './layout';
+export { AepStageLayoutProvider, useAepStageLayoutListener } from './AepStageLayoutContext';
+export type { StageLayoutEvent, StageLayoutListener } from './AepStageLayoutContext';
+export { STAGE_MEMBER_HANDLERS } from './members/registry';
+export type { StageMemberHandler, StageMemberRig, StageBuildContext } from './members/types';

package/dist/components/AepComposition/stage3d/layout.d.ts

@@ -0,0 +1,16 @@
+import * as THREE from "three";
+export interface StageRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * Bounding rect of `box` seen through `camera`, clamped to the viewport.
+ * Returns null when any corner is behind the camera (the projection is not
+ * meaningful) or the box falls entirely outside the viewport.
+ */
+export declare function projectBoxToViewport(box: THREE.Box3, camera: THREE.PerspectiveCamera, viewport: {
+    width: number;
+    height: number;
+}): StageRect | null;

package/dist/components/AepComposition/stage3d/members/actor3d.d.ts

@@ -0,0 +1,10 @@
+import { AepActor3DLayer } from '../../../../types/aep';
+import { StageMemberHandler, StageMemberRig } from './types';
+import * as THREE from "three";
+export interface ActorRig extends StageMemberRig {
+    model: THREE.Object3D;
+    mixer: THREE.AnimationMixer;
+    actions: (THREE.AnimationAction | null)[];
+    durations: number[];
+}
+export declare const actor3dHandler: StageMemberHandler<AepActor3DLayer>;

package/dist/components/AepComposition/stage3d/members/normalize.d.ts

@@ -0,0 +1,19 @@
+import * as THREE from "three";
+export interface Normalized {
+    /** Uniform scale applied to the model. */
+    scale: number;
+}
+/**
+ * Scales `model` uniformly so `measure(size)` equals `target`, then puts its
+ * bottom on y = 0 and centres it in x/z. Uses the rest pose (call before any
+ * animation plays). Returns the scale applied.
+ */
+export declare function normalizeModel(model: THREE.Object3D, target: number, measure: (size: THREE.Vector3) => number): Normalized;
+/**
+ * Scale from the first mesh's geometry units to world metres (outline width
+ * basis). Measured as rendered rest-pose size / geometry size rather than read
+ * from `matrixWorld`: a skinned mesh bound in "attached" mode cancels its
+ * parent scale (a cm rig under a 0.01 armature renders at the geometry's own
+ * scale), so the matrix would be off by that factor.
+ */
+export declare function meshWorldScale(root: THREE.Object3D): number;

package/dist/components/AepComposition/stage3d/members/prop3d.d.ts

@@ -0,0 +1,3 @@
+import { AepProp3DLayer } from '../../../../types/aep';
+import { StageMemberHandler } from './types';
+export declare const prop3dHandler: StageMemberHandler<AepProp3DLayer>;

package/dist/components/AepComposition/stage3d/members/registry.d.ts

@@ -0,0 +1,9 @@
+import { AepStageMemberLayer } from '../../../../types/aep';
+import { StageMemberHandler } from './types';
+export declare const STAGE_MEMBER_HANDLERS: {
+    [K in AepStageMemberLayer["kind"]]: StageMemberHandler<Extract<AepStageMemberLayer, {
+        kind: K;
+    }>>;
+};
+/** Kind-erased lookup for code that iterates mixed members. */
+export declare function handlerFor(layer: AepStageMemberLayer): StageMemberHandler<AepStageMemberLayer>;

package/dist/components/AepComposition/stage3d/members/types.d.ts

@@ -0,0 +1,43 @@
+import { GLTF } from 'three/examples/jsm/loaders/GLTFLoader.js';
+import { AepStageMemberLayer } from '../../../../types/aep';
+import type * as THREE from "three";
+export interface StageBuildContext {
+    /** assetId -> resolved URL. */
+    urls: Readonly<Record<string, string>>;
+    /** Per-world cache. Never mutate or add the result to a scene: clone it. */
+    loadGltf(url: string): Promise<GLTF>;
+    /** Uncached: every call returns a texture the caller owns. */
+    loadTexture(url: string): Promise<THREE.Texture>;
+    /** Members already built (lower `order` first). */
+    rigs: ReadonlyMap<string, StageMemberRig>;
+    /** console.warn once per message per world. */
+    warn(message: string): void;
+}
+export interface StageMemberRig {
+    id: string;
+    /** Added to `world.membersRoot` by the world unless it already has a parent. */
+    root: THREE.Object3D;
+    /** Per-frame and stateless: the same sample gives the same pose whatever came before. */
+    apply(sample: unknown): void;
+    /** World-space box, for layout rects. */
+    worldBox(target: THREE.Box3): THREE.Box3;
+    /** Scale from the member's local units to world metres, for world-metre outlines. */
+    worldScale: number;
+    dispose(): void;
+}
+export interface StageMemberHandler<L extends AepStageMemberLayer> {
+    kind: L["kind"];
+    /** Lower builds first: actors 0, props 1 (attach needs actor bones). */
+    order: number;
+    /** Asset ids to resolve before build. */
+    assetIds(layer: L): string[];
+    /**
+     * JSON-able. A change rebuilds THIS member only, so it excludes per-frame
+     * fields (marks, position/rotation/scale keyframes, inPoint/outPoint, hidden).
+     */
+    structureOf(layer: L): unknown;
+    sample(layer: L, frame: number, fps: number): {
+        active: boolean;
+    };
+    build(layer: L, ctx: StageBuildContext): Promise<StageMemberRig>;
+}

package/dist/components/AepComposition/stage3d/reconcile.d.ts

@@ -0,0 +1,22 @@
+export interface ReconcileMember {
+    id: string;
+    /** Includes resolved asset URLs (and, for an attached prop, its actor's key). */
+    key: string;
+    /** Set for a prop attached to an actor: rebuilds when that actor does. */
+    attachTo?: string;
+    order: number;
+}
+export interface ReconcileState {
+    worldKey: string | null;
+    members: ReconcileMember[];
+}
+export interface ReconcilePlan {
+    rebuildWorld: boolean;
+    /** Members to build from scratch, in build order. */
+    build: string[];
+    /** Members to dispose and build again, in build order. */
+    rebuild: string[];
+    /** Members to dispose and not rebuild. */
+    dispose: string[];
+}
+export declare function planReconcile(prev: ReconcileState, next: ReconcileState): ReconcilePlan;

package/dist/components/AepComposition/stage3d/sampleStage3D.d.ts

@@ -0,0 +1,75 @@
+import { AepActor3DLayer, AepProp3DLayer, AepStage3DLayer, AepStageClip, AepStageMemberLayer } from '../../../types/aep';
+import { LightingPresetName } from '../model3d/lighting';
+type Vec3 = [number, number, number];
+export interface SampledClipWeight {
+    clipIndex: number;
+    /** 0..1; the weights of an actor sum to 1 (or the actor has none). */
+    weight: number;
+    /** Unclamped clip time: offset + max(0, F - startFrame) / fps * speed. */
+    rawSeconds: number;
+    loop: boolean;
+}
+export interface SampledSpot {
+    id: string;
+    position: Vec3;
+    target: Vec3;
+    intensity: number;
+    angleDeg: number;
+}
+export interface SampledStageLighting {
+    preset: LightingPresetName;
+    keyAzimuth: number;
+    keyElevation: number;
+    keyIntensity: number;
+    keyColor: string;
+    fillIntensity: number;
+    rimIntensity: number;
+    ambient: number;
+    environment: "room" | "none";
+}
+export declare const STAGE3D_DEFAULTS: {
+    readonly shadowOpacity: 0.55;
+    readonly shadowSoftness: 0.5;
+    readonly spotAngle: 25;
+};
+/**
+ * Which clips are audible at composition frame `F`, with blend weights.
+ * Linear weights, at most two clips at once (the schema enforces spacing).
+ */
+export declare function scheduleClips(clips: readonly AepStageClip[], F: number, fps: number): SampledClipWeight[];
+/**
+ * Seconds to put an action at. Looping wraps; otherwise the pose holds just
+ * inside the last key (at exactly `duration` a repeating action wraps to the
+ * first pose). Same hold rule as model3d's `animationTimeSeconds`.
+ */
+export declare function clipLocalTime(rawSeconds: number, duration: number, loop: boolean): number;
+/** A member is in the scene while !hidden and inPoint <= F < outPoint. */
+export declare function memberActive(layer: AepStageMemberLayer, F: number): boolean;
+export interface SampledStageWorld {
+    lighting: SampledStageLighting;
+    spots: SampledSpot[];
+    shadowOpacity: number;
+    shadowSoftness: number;
+    focusDistance: number | null;
+}
+export declare function sampleStageWorld(world: AepStage3DLayer, F: number): SampledStageWorld;
+export interface SampledActor3D {
+    id: string;
+    active: boolean;
+    x: number;
+    z: number;
+    facingDeg: number;
+    clips: SampledClipWeight[];
+}
+export declare function sampleActor3D(actor: AepActor3DLayer, F: number, fps: number): SampledActor3D;
+export interface SampledProp3D {
+    id: string;
+    active: boolean;
+    position: Vec3;
+    rotationDeg: Vec3;
+    scale: Vec3;
+}
+export declare function sampleProp3D(prop: AepProp3DLayer, F: number): SampledProp3D;
+/** Dirty-check key for one render: the world plus every member, in member order. */
+export declare function stageFrameKey(world: SampledStageWorld, members: readonly unknown[]): string;
+export {};

package/dist/components/AepComposition/stage3d/style.d.ts

@@ -0,0 +1,21 @@
+import { AepStage3DLayer } from '../../../types/aep';
+import { StageWorld } from './buildWorld';
+import { StageMemberRig } from './members/types';
+export interface ResolvedStageStyle {
+    toon: boolean;
+    steps: number;
+    outline: {
+        color: string;
+        width: number;
+    } | null;
+    exposure: number;
+}
+export declare function resolveStageStyle(style: AepStage3DLayer["style"]): ResolvedStageStyle;
+/**
+ * Applies the style to a built member. Outline width is in world metres:
+ * `width / worldScale` converts it to the member's local units, so a 0.012 m
+ * line looks the same on a tiny prop and a big actor.
+ */
+export declare function styleMember(rig: StageMemberRig, style: ResolvedStageStyle): void;
+/** Ground and wall: toon shading, never an outline. A backdrop wall stays unlit. */
+export declare function styleWorldSurfaces(world: StageWorld, style: ResolvedStageStyle): void;

package/dist/components/AepComposition/useAepLayerTransform.d.ts

@@ -1,4 +1,4 @@
-import { AepLayer } from '../../types/aep';
+import { AepLayer, AepStageMemberLayer } from '../../types/aep';
 export interface AepResolvedTransform {
     x: number;
     y: number;
@@ -12,7 +12,7 @@ export interface AepResolvedTransform {
         y: number;
     };
 }
-export declare function useAepLayerTransform(layer: AepLayer, intrinsicSize: {
+export declare function useAepLayerTransform(layer: Exclude<AepLayer, AepStageMemberLayer>, intrinsicSize: {
     width: number;
     height: number;
 }): AepResolvedTransform;

package/dist/components/AepComposition/useResolveAsset.d.ts

@@ -6,3 +6,4 @@ export interface AepResolvedAssetState {
     error?: unknown;
 }
 export declare function useResolveAsset(assetId: string | undefined): AepResolvedAssetState;
+export declare function useResolveAssets(assetIds: readonly string[]): Record<string, AepResolvedAssetState>;

package/dist/hocs/AbstractContainer.d.ts

@@ -5,6 +5,15 @@ interface AbstractContainerProps extends PixiBaseSpriteProps {
     /** Container label/id override. Defaults to `getElementName(uniqueId)`. */
     id?: string;
     sortableChildren?: boolean;
+    /**
+     * Shifts the scale/rotation pivot away from (x, y) without moving the
+     * content. Used by precomps so keyframed scale/rotation act about the AE
+     * anchor point instead of the precomp's top-left corner.
+     */
+    pivotOffset?: {
+        x: number;
+        y: number;
+    };
     /** Text handed to text-unit / typewriter effects (see usePixiAnimation). */
     animationText?: string;
     ignoreTlForVideo?: boolean;

package/dist/importers/aep/index.d.ts

@@ -6,3 +6,4 @@ export { lottieColorToHex } from './bodymovin-color';
 export { lintBodymovinJson, LottieLintError, type LintFinding, type LintReport, type LintSeverity, type LintOptions, } from './lottieLint';
 export { readPostFxExtension, readExtrusionExtension, } from './bodymovinExtensions';
 export { lintAepTransitions } from './transitionLint';
+export { lintAepStage3D } from './stageLint';

package/dist/importers/aep/stageLint.d.ts

@@ -0,0 +1,3 @@
+import { AepCompositionJson } from '../../types/aep';
+import { LintReport } from './lottieLint';
+export declare const lintAepStage3D: (comp: AepCompositionJson) => LintReport;