@vvfx/ge-ir 0.0.1-beta.7 → 0.0.1-beta.8

package/dist/ir2ge/assemble.d.ts

@@ -0,0 +1,8 @@
+import { type IRComposition } from '@vvfx/animation-ir';
+import type { JSONScene } from '@galacean/effects-specification';
+import type { ECSCollector, GeneratedItemBinding } from './types';
+/**
+ * Assemble a GE JSONScene from generated pools and preserved source resources.
+ * `duration` overrides the value derived from the IR frame bounds.
+ */
+export declare function assembleGEScene(ir: IRComposition, collector: ECSCollector, itemBindings: GeneratedItemBinding[], duration?: number): JSONScene;

package/dist/ir2ge/converter/animation.d.ts

@@ -0,0 +1,5 @@
+import type { IRComposition, IRLayerNode } from '@vvfx/animation-ir';
+import type { ColorOverLifetime } from '@galacean/effects-specification';
+import type { GEAnimationPayload, LayerGenerationContext, TransformAnimation } from '../types';
+export declare function buildTransformAnimation(layer: IRLayerNode, ctx: LayerGenerationContext): TransformAnimation;
+export declare function buildColorAnimation(layer: IRLayerNode, ir: IRComposition): GEAnimationPayload<ColorOverLifetime> | undefined;

package/dist/ir2ge/converter/bezier.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Encode IR keyframes as GE BezierKeyframeValue payloads.
+ *
+ * Wire format:
+ * - First:  [EASE_OUT(3), [t, v, out_cp_x, out_cp_y]]
+ * - Middle: [EASE(1),     [in_cp_x, in_cp_y, t, v, out_cp_x, out_cp_y]]
+ * - Last:   [EASE_IN(2),  [in_cp_x, in_cp_y, t, v]]
+ *
+ * Time is normalized to the layer's visible frame range.
+ */
+import type { IRAnimatedProperty, IRVec3 } from '@vvfx/animation-ir';
+import { type BezierKeyframeValue } from '@galacean/effects-specification';
+export interface IRToGETimeContext {
+    /** Layer visible start frame. */
+    startFrame: number;
+    /** Layer visible end frame. */
+    endFrame: number;
+}
+interface GEPositionAnimationData {
+    /** One-dimensional timing curves in BezierKeyframeValue format. */
+    curves: BezierKeyframeValue[][];
+    /** Segment endpoints as `[[startX, startY], [endX, endY]]`. */
+    pathPoints: [[number, number], [number, number]][];
+    /** Segment control offsets as `[[outX, outY], [inX, inY]]`. */
+    controlPoints: [[number, number], [number, number]][];
+}
+/** Convert a scalar property to a single GE Bezier curve. */
+export declare function convertIRScalarKeyframesToGE(property: IRAnimatedProperty<number>, timeContext: IRToGETimeContext): BezierKeyframeValue[][] | undefined;
+/** Convert a vector property to one GE Bezier curve per dimension. */
+export declare function convertIRVectorKeyframesToGE(property: IRAnimatedProperty<IRVec3>, timeContext: IRToGETimeContext): BezierKeyframeValue[][] | undefined;
+/** Convert position keyframes to GE path, control-point, and timing payloads. */
+export declare function convertIRPositionKeyframesToGE(property: IRAnimatedProperty<IRVec3>, timeContext: IRToGETimeContext): GEPositionAnimationData | undefined;
+/** Return whether GE's compact keyframe fields are required for this property. */
+export declare function shouldUseKeyframeMode(property: IRAnimatedProperty): boolean;
+export {};

package/dist/ir2ge/converter/layer-strategy.d.ts

@@ -0,0 +1,18 @@
+import type { IRComposition, IRLayerNode } from '@vvfx/animation-ir';
+/**
+ * Anchor encoding strategy.
+ *
+ * - `inline-anchor` encodes the renderer anchor and compensates item position.
+ * - `split-null-sprite` places transforms on a null parent and visual content
+ *   on an anchor-offset child.
+ * Effects passthrough data may request the source hierarchy.
+ */
+type LayerGenerationStrategy = {
+    kind: 'inline-anchor';
+    anchorScale: [number, number];
+    anchorOffset: [number, number];
+} | {
+    kind: 'split-null-sprite';
+};
+export declare function resolveLayerGenerationStrategy(ir: IRComposition, layer: IRLayerNode): LayerGenerationStrategy;
+export {};

package/dist/ir2ge/converter/normalized-animation.d.ts

@@ -0,0 +1,15 @@
+import type { IRLayerNode } from '@vvfx/animation-ir';
+import type { ColorOverLifetime, TransformPlayableAssetData } from '@galacean/effects-specification';
+interface NormalizedAnimationContext {
+    width: number;
+    height: number;
+}
+type NormalizedTransformAnimation = Pick<TransformPlayableAssetData, 'positionOverLifetime' | 'rotationOverLifetime' | 'sizeOverLifetime'>;
+/**
+ * Encode normalized IR transform channels as GE timeline payloads without
+ * consulting composition-specific passthrough data.
+ */
+export declare function buildNormalizedTransformAnimation(layer: IRLayerNode, ctx: NormalizedAnimationContext): NormalizedTransformAnimation;
+/** Encode normalized IR opacity as a GE color-over-lifetime payload. */
+export declare function buildNormalizedColorAnimation(layer: IRLayerNode): ColorOverLifetime | undefined;
+export {};

package/dist/ir2ge/converter/timing.d.ts

@@ -0,0 +1,14 @@
+import type { IRLayerNode } from '@vvfx/animation-ir';
+/**
+ * Convert an IR frame range to GE delay and duration, including stretch and
+ * offset semantics. Degenerate durations use a minimal activation interval.
+ */
+export declare function computeLayerTiming(layer: IRLayerNode, frameRate: number, compositionInPoint?: number): {
+    delay: number;
+    layerDuration: number;
+};
+/**
+ * Extend transform-parent lifetimes to cover independent children. GE requires
+ * the parent item to remain active for transform inheritance.
+ */
+export declare function extendParentEndFrames(layers: IRLayerNode[], parentIndexSet: Set<number>): IRLayerNode[];

package/dist/ir2ge/{ir/layer-utils.d.ts → converter/transform.d.ts}

@@ -1,8 +1,9 @@
 import type { IRLayerNode, IRLocalBounds } from '@vvfx/animation-ir';
-import type { IRToGETimeContext } from '../builders/bezier';
-import type { LayerProcessingContext } from '../types';
-export { computeLayerTiming } from '../builders/timing';
-export declare function computeStaticPosition(layer: IRLayerNode, ctx: LayerProcessingContext, anchorOffsetX?: number, anchorOffsetY?: number): [number, number, number];
+import type { IRToGETimeContext } from './bezier';
+import type { LayerGenerationContext } from '../types';
+export declare function getLayerLocalBounds(layer: IRLayerNode, fallback?: IRLocalBounds): IRLocalBounds;
+export declare function hasIndependentParentLifetime(layer: IRLayerNode): boolean;
+export declare function computeStaticPosition(layer: IRLayerNode, ctx: LayerGenerationContext, anchorOffsetX?: number, anchorOffsetY?: number): [number, number, number];
 export declare function getStaticAnchor(layer: IRLayerNode): [number, number];
 export declare function applyScalePositionAdjust(position: [number, number, number], layer: IRLayerNode, bounds: IRLocalBounds, ratio: number): [number, number, number];
 export declare function computeAnchorInfo(layer: IRLayerNode, bounds: IRLocalBounds): {

package/dist/ir2ge/generator/component.d.ts

@@ -0,0 +1,9 @@
+import type { IRComposition, IRLayerNode, IRShapeData } from '@vvfx/animation-ir';
+import type { GeneratedComponentData, LayerGenerationContext } from '../types';
+export declare function buildComponent(layer: IRLayerNode, itemId: string, anchorScaleX: number, anchorScaleY: number, ctx: LayerGenerationContext): string | undefined;
+/**
+ * Copy a preserved GE mask to the generated component. Target references still
+ * use source component IDs and are remapped after generation.
+ */
+export declare function copyPassthroughMaskToComponent(ir: IRComposition, layer: IRLayerNode, component: GeneratedComponentData): void;
+export declare function buildShapeOptions(shapeData: IRShapeData, ratio: number, ctx?: LayerGenerationContext): Record<string, unknown>;

package/dist/ir2ge/generator/layer.d.ts

@@ -0,0 +1,6 @@
+import type { IRLayerNode } from '@vvfx/animation-ir';
+import type { LayerGenerationContext } from '../types';
+export declare function appendNullLayer(layer: IRLayerNode, ctx: LayerGenerationContext): void;
+export declare function appendPrecompLayer(layer: IRLayerNode, ctx: LayerGenerationContext): void;
+export declare function appendParentLayer(layer: IRLayerNode, ctx: LayerGenerationContext): void;
+export declare function appendVisualLayer(layer: IRLayerNode, ctx: LayerGenerationContext): void;

package/dist/ir2ge/generator/timeline.d.ts

@@ -0,0 +1,7 @@
+import { type EndBehavior, ItemType } from '@galacean/effects-specification';
+import type { ECSCollector, TransformAnimation } from '../types';
+/**
+ * Build binding, activation, transform, and optional color tracks for one item.
+ * Null and precomposition items omit the color track.
+ */
+export declare function buildTimelineTracks(collector: ECSCollector, delay: number, duration: number, endBehavior: EndBehavior, animation: TransformAnimation, itemType: ItemType): string;

package/dist/ir2ge/index.d.ts

@@ -1,14 +1,10 @@
-export { convertIRToGE } from './assembly/generator';
-export type { DataPath, JSONScene } from '@galacean/effects-specification';
-export { readLottieSpecific } from './ir/specific';
-export type { LottieLayerSpecific } from './ir/specific';
-export { hasIndependentParentLifetime } from './ir/parent-link';
-export type { ECSCollector, GEDataPath, GEItem, GEPoolIndex, GERecord, GETransform } from '../shared/types';
-export type { ProcessedItem, TransformAnimation } from './types';
-export { assembleScene } from './assembly/scene-assembly';
-export { estimateTextWidth, roundNumber, lerp, createId, toDataPath } from './utils';
-export { DEFAULT_CLIP_MODE, DEFAULT_CAMERA_FOV, DEFAULT_CAMERA_Z, get2dTo3dRatio, convert2dTo3dPoint, } from '../shared/coordinate';
-export { irScalarKeyframesToGE, irVectorKeyframesToGE, irPositionKeyframesToGE, shouldUseKeyframeMode, } from './builders/bezier';
-export type { IRToGETimeContext, IRPositionGEResult } from './builders/bezier';
-export { buildTimelineTracks } from './builders/timeline';
-export { normalizeChildVisibilityByParentDelays } from './post-process/visibility';
+import { type IRComposition } from '@vvfx/animation-ir';
+import type { JSONScene } from '@galacean/effects-specification';
+/**
+ * Convert an IR composition to a GE JSONScene.
+ *
+ * Effects passthrough data is used only to preserve source hierarchy, masks,
+ * precompositions, and animation encodings that normalized IR cannot represent.
+ * `duration` overrides the range derived from the IR frame bounds.
+ */
+export declare function convertIRToGE(ir: IRComposition, duration?: number): JSONScene;

package/dist/ir2ge/mapping.d.ts

@@ -0,0 +1,5 @@
+import { IRBlendMode } from '@vvfx/animation-ir';
+import { ItemType } from '@galacean/effects-specification';
+export declare function mapBlendModeToGE(blendMode: IRBlendMode | undefined): number | undefined;
+export declare function mapLayerTypeToGETimelineType(type: string): ItemType;
+export declare function mapLayerTypeToGEItemType(type: string): ItemType;

package/dist/ir2ge/post-process/ge-mask-remap.d.ts

@@ -1,18 +1,6 @@
 import type { ECSCollector } from '../types';
 /**
- * Remap GE mask references after ge2ir round-trip.
- *
- * ge2ir carries each masked component's raw `mask` object verbatim (via
- * `IRLayerNode.specific.effects.mask`), but `mask.reference.id` still points at the
- * ORIGINAL (GE1) mask-source component id, which ir2ge has regenerated. This
- * pass rewrites every target's `reference.id` from the stale GE1 id to the
- * freshly-minted GE2 component id, using the `GEComponentId → newId` map built
- * during the layer walk.
- *
- * Mirrors `applyParenting`: an IR-side reference (here the stale id stored in
- * data) → map → regenerated id → written in place. Mask SOURCE components have
- * no `reference` and are skipped. Dangling references (source not regenerated —
- * e.g. dropped by the null+sprite merger) have their `mask` removed so the GE
- * runtime doesn't choke on an id that resolves to nothing.
+ * Remap preserved mask targets from source component IDs to regenerated IDs.
+ * Source masks have no reference; unresolved target masks are removed.
  */
 export declare function applyGEMaskRemap(collector: ECSCollector, GEComponentIdToNewId: Record<string, string>): void;

package/dist/ir2ge/post-process/index.d.ts

@@ -1,18 +1,11 @@
 import type { IRComposition } from '@vvfx/animation-ir';
-import type { ECSCollector, ProcessedItem } from '../types';
+import type { ECSCollector, GeneratedItemBinding } from '../types';
 import { type MaskLayerLookup } from './mask';
-export type { MaskLayerLookup } from './mask';
-/**
- * Post-emit state populated by the unified pipeline's per-layer walk.
- * All fields beyond `collector` + `processedItems` are optional — each
- * post-process step is gated on the presence of the data it needs, not
- * on `ir.source`. Steps that only apply to certain sources naturally
- * no-op when the relevant data is absent (e.g. dsl IR has no masks).
- */
-export interface PostProcessState {
+/** Generation state consumed by optional post-processing steps. */
+interface PostProcessState {
     collector: ECSCollector;
-    processedItems: ProcessedItem[];
-    /** Per-layer lookups consumed by the shared mask post-process. */
+    itemBindings: GeneratedItemBinding[];
+    /** Per-layer lookups used during mask generation. */
     maskLookup?: MaskLayerLookup;
     layerToItemId?: Record<number, string>;
     parentIndexSet?: Set<number>;
@@ -20,12 +13,9 @@ export interface PostProcessState {
     width?: number;
     height?: number;
     frameRate?: number;
-    /** GE1→GE2 component-id map for remapping ge2ir mask passthrough references. */
+    /** Source-to-generated component ID map for preserved mask references. */
     GEComponentIdToNewId?: Record<string, string>;
 }
-/**
- * Run post-emit mutations on the collector before `assembleScene`.
- * Order: parenting → mask → visibility. Each step is gated on whether
- * the pipeline supplied the required tracking state.
- */
+/** Run ordered post-generation passes before scene assembly. */
 export declare function applyPostProcess(ir: IRComposition, state: PostProcessState): void;
+export {};

package/dist/ir2ge/post-process/mask.d.ts

@@ -1,26 +1,13 @@
 /**
- * Mask post-process: emits a mask shape item + component for each layer that
- * carries `IRMaskData`, propagating the mask reference to the layer's renderer
- * component or — for parent layers — to descendant renderers.
- *
- * The decision to emit (per-layer) is gated solely on `layer.mask != null`,
- * so any IR producer can opt in by writing the field. Currently only lottie
- * IR has masks; dsl IR leaves `mask` undefined and this module no-ops for it.
- *
- * The lookup callbacks let each pipeline plug in its own layer-to-emitted-id
- * mapping — lottie keeps `layerToItemId`/`layerToComponentId`/`parentIndexSet`
- * during emission, dsl tracks differently. Mask handling stays generic.
+ * Generate GE mask items for masked IR layers and attach references to direct
+ * or descendant renderer components.
  */
 import type { IRComposition } from '@vvfx/animation-ir';
-import type { ECSCollector, ProcessedItem } from '../types';
-/**
- * Pipeline-specific lookups consumed during mask emission. A pipeline that
- * never produces masks can pass stub callbacks (the iterator skips layers
- * without `mask`, so the callbacks are never invoked in that case).
- */
+import type { ECSCollector, GeneratedItemBinding } from '../types';
+/** Resolve IR layer indices to generated items and components. */
 export interface MaskLayerLookup {
     getItemId(layerIndex: number): string | undefined;
     getComponentId(layerIndex: number): string | undefined;
     isParentLayer(layerIndex: number): boolean;
 }
-export declare function applyMasks(ir: IRComposition, collector: ECSCollector, processedItems: ProcessedItem[], ratio: number, width: number, height: number, frameRate: number, lookup: MaskLayerLookup): void;
+export declare function applyMasks(ir: IRComposition, collector: ECSCollector, itemBindings: GeneratedItemBinding[], ratio: number, width: number, height: number, frameRate: number, lookup: MaskLayerLookup): void;

package/dist/ir2ge/post-process/merge-preserved-resources.d.ts

@@ -0,0 +1,3 @@
+import type { IRComposition } from '@vvfx/animation-ir';
+/** Merge non-root pools retained from a source GE scene into the generated scene. */
+export declare function mergePreservedResources(generated: Record<string, unknown>, ir: IRComposition): Record<string, unknown>;

package/dist/ir2ge/post-process/parenting.d.ts

@@ -1,3 +1,3 @@
 import type { IRLayerNode } from '@vvfx/animation-ir';
-import type { GEItem } from '../types';
-export declare function applyParenting(layers: IRLayerNode[], items: GEItem[], layerToItemId: Record<number, string>, ratio: number, width: number, height: number): void;
+import type { GeneratedVFXItemData } from '../types';
+export declare function applyParenting(layers: IRLayerNode[], items: GeneratedVFXItemData[], layerToItemId: Record<number, string>, ratio: number, width: number, height: number): void;

package/dist/ir2ge/post-process/visibility.d.ts

@@ -1,26 +1,22 @@
-interface ProcessedItemRef {
+import type { VFXItemData } from '@galacean/effects-specification';
+import type { GeneratedMiscData } from '../types';
+type VisibilityItem = Pick<VFXItemData, 'id' | 'delay' | 'duration' | 'parentId'>;
+interface GeneratedItemBindingRef {
     itemId: string;
     objectBindingTrackId: string;
 }
 interface NormalizeVisibilityParams {
-    items: Record<string, unknown>[];
-    miscs: Record<string, unknown>[];
-    processedItems: ProcessedItemRef[];
+    items: VisibilityItem[];
+    miscs: GeneratedMiscData[];
+    itemBindings: GeneratedItemBindingRef[];
     /** Child item IDs whose lifetime is independent of the transform parent's window. */
     independentLifetimeChildItemIds?: Set<string>;
     roundNumber: (value: number, precision: number) => number;
 }
 /**
- * Normalize child visibility delays so children never appear before their parent.
- *
- * Topologically sorts items (parent-first) so by the time we process any child
- * its parent's delay/duration are already finalized. For children with an
- * independent lifetime, we instead advance the parent's delay/duration so the
- * child can render from its own start time (GE requires the parent to be active
- * for transform inheritance, but the parent-link relationship does not propagate
- * visibility). Only the ActivationTrack clip is updated; TransformTrack
- * keyframes are normalized to the original time range and would hold their
- * first frame value if the track started earlier.
+ * Normalize item lifetimes in parent-first order. Contained children are clamped
+ * to their parent; independent children extend the transform parent's activation
+ * interval. Transform keyframes retain their original time domain.
  */
-export declare function normalizeChildVisibilityByParentDelays({ items, miscs, processedItems, independentLifetimeChildItemIds, roundNumber, }: NormalizeVisibilityParams): void;
+export declare function normalizeChildVisibilityByParentDelays({ items, miscs, itemBindings, independentLifetimeChildItemIds, roundNumber, }: NormalizeVisibilityParams): void;
 export {};

package/dist/ir2ge/types.d.ts

@@ -1,31 +1,40 @@
 import type { IRComposition } from '@vvfx/animation-ir';
-import type { DataPath } from '@galacean/effects-specification';
-import type { ECSCollector } from '../shared/types';
-export type { ECSCollector, GEDataPath, GEItem, GEPoolIndex, GERecord, GETransform } from '../shared/types';
-/**
- * Bookkeeping for a fully emitted item: its VFXItemData id and the
- * ObjectBindingTrack that owns its child Activation/Transform/SpriteColor
- * tracks. The optional `layerIndex` lets source-specific post-processing
- * (e.g. lottie visibility normalization) trace items back to the IR layer.
- */
-export interface ProcessedItem {
+import type { ColorOverLifetime, ComponentData, DataPath, EffectsObjectData, JSONScene, PositionOverLifetime, RotationOverLifetime, SizeOverLifetime, VFXItemData } from '@galacean/effects-specification';
+/** Generated item with a required transform and optional deprecated content. */
+export type GeneratedVFXItemData = Omit<VFXItemData, 'content' | 'transform'> & Partial<Pick<VFXItemData, 'content'>> & Required<Pick<VFXItemData, 'transform'>>;
+/** Generated component with specification fields and preserved extension data. */
+export type GeneratedComponentData = ComponentData & Record<string, unknown>;
+/** Generated misc object with specification fields and timeline payloads. */
+export type GeneratedMiscData = EffectsObjectData & Record<string, unknown>;
+/** Pools collected while building a GE JSONScene. */
+export interface ECSCollector {
+    images: JSONScene['images'];
+    components: GeneratedComponentData[];
+    items: GeneratedVFXItemData[];
+    textures: NonNullable<JSONScene['textures']>;
+    miscs: GeneratedMiscData[];
+}
+/** Links a generated item and its binding track to the originating IR layer. */
+export interface GeneratedItemBinding {
     itemId: string;
     objectBindingTrackId: string;
     layerIndex?: number;
 }
+/** Specification-defined GE animation data or an opaque preserved payload. */
+export type GEAnimationPayload<T> = T | Record<string, unknown>;
 /** Per-channel animation payload consumed by the timeline tracks. */
 export interface TransformAnimation {
-    positionOverLifetime?: Record<string, unknown> | null;
-    rotationOverLifetime?: Record<string, unknown> | null;
-    sizeOverLifetime?: Record<string, unknown> | null;
-    colorOverLifetime?: Record<string, unknown> | null;
+    positionOverLifetime?: GEAnimationPayload<PositionOverLifetime>;
+    rotationOverLifetime?: GEAnimationPayload<RotationOverLifetime>;
+    sizeOverLifetime?: GEAnimationPayload<SizeOverLifetime>;
+    colorOverLifetime?: GEAnimationPayload<ColorOverLifetime>;
 }
-/** Per-layer context threaded through the unified layer processors. */
-export interface LayerProcessingContext {
-    /** Full IR composition; needed for normalized semantics and guarded fidelity payloads. */
+/** Shared context for layer generation. */
+export interface LayerGenerationContext {
+    /** IR composition used for normalized semantics and source-fidelity data. */
     ir: IRComposition;
     collector: ECSCollector;
-    processedItems: ProcessedItem[];
+    itemBindings: GeneratedItemBinding[];
     layerToItemId: Record<number, string>;
     layerToComponentId: Record<number, string>;
     textureCache: Map<string, DataPath>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vvfx/ge-ir",
-  "version": "0.0.1-beta.7",
+  "version": "0.0.1-beta.8",
   "description": "Galacean Effects and animation IR bidirectional conversion package",
   "module": "./dist/index.mjs",
   "main": "./dist/index.js",
@@ -16,9 +16,9 @@
     }
   },
   "dependencies": {
-    "@galacean/effects-specification": "^2.8.0",
+    "@galacean/effects-specification": "2.7.2",
     "uuid": "^13.0.0",
-    "@vvfx/animation-ir": "0.0.1-beta.7"
+    "@vvfx/animation-ir": "0.0.1-beta.8"
   },
   "contributors": [
     {

package/dist/ge2ir/converter.d.ts

@@ -1,3 +0,0 @@
-import type { IRComposition } from '@vvfx/animation-ir';
-import type { GE2IROptions } from './types';
-export declare function convertGEToIR(scene: Record<string, unknown>, options: GE2IROptions): IRComposition;

package/dist/ge2ir/pool/pool.d.ts

@@ -1,4 +0,0 @@
-import type { GEPoolIndex, GERecord } from '../../shared/types';
-export declare function buildPoolIndex(pool: GERecord[] | undefined): GEPoolIndex;
-export declare function resolveDataPath(pool: GEPoolIndex, ref: unknown): GERecord | undefined;
-export declare function resolveDataPathId(ref: unknown): string | undefined;

package/dist/ge2ir/reverse/blend-mode.d.ts

@@ -1,2 +0,0 @@
-import type { IRBlendMode as IRBlendModeType } from '@vvfx/animation-ir';
-export declare function reverseBlendMode(GECode: number | undefined): IRBlendModeType | undefined;

package/dist/ge2ir/reverse/coordinate.d.ts

@@ -1 +0,0 @@
-export declare function convert3dTo2dPoint(x: number, y: number, z: number, width: number, height: number): [number, number, number];

package/dist/ge2ir/reverse/end-behavior.d.ts

@@ -1,3 +0,0 @@
-import type { IREndBehavior as IREndBehaviorType } from '@vvfx/animation-ir';
-export declare function reverseEndBehavior(GEBehavior: number | undefined): IREndBehaviorType | undefined;
-export declare function reverseCompositionEndBehavior(GEBehavior: number | undefined): IREndBehaviorType | undefined;

package/dist/ge2ir/reverse/timing.d.ts

@@ -1,2 +0,0 @@
-import type { IRTimeContext } from '@vvfx/animation-ir';
-export declare function reverseLayerTiming(delay: number, duration: number, frameRate: number): IRTimeContext;

package/dist/ir2ge/assembly/generator.d.ts

@@ -1,21 +0,0 @@
-/**
- * Unified IR → GE scene generation pipeline. All IR sources (lottie, dsl,
- * future) are processed here. Normalized animation semantics select the GE
- * lowering plan; source-specific payloads are consulted only for fidelity
- * restoration such as GE hierarchy, mask and precomp graphs.
- */
-import { type IRComposition } from '@vvfx/animation-ir';
-import type { JSONScene } from '@galacean/effects-specification';
-/**
- * Convert an IR composition to a GE JSONScene.
- *
- * All IR sources (lottie, dsl, future) go through this single unified
- * pipeline. Normalized animation semantics select the GE lowering plan;
- * source-specific payloads may preserve authored GE hierarchy or restore
- * mask and precomp graphs.
- *
- * The optional `duration` arg is a caller override; lottie2ge currently passes
- * the duration computed from the raw json upstream. When omitted, the
- * canonical assembler derives it from `(outPoint - inPoint) / frameRate`.
- */
-export declare function convertIRToGE(ir: IRComposition, duration?: number): JSONScene;

package/dist/ir2ge/assembly/scene-assembly.d.ts

@@ -1,11 +0,0 @@
-import { type IRComposition } from '@vvfx/animation-ir';
-import { type JSONScene } from '@galacean/effects-specification';
-import type { ECSCollector, ProcessedItem } from '../types';
-/**
- * Assemble the top-level GE JSONScene wrapper from a populated collector.
- *
- * Reads composition-level properties (`name`, `width`/`height`, `endBehavior`,
- * `backgroundColor`) directly from the IR. The optional `duration` arg is a
- * caller override — when omitted, derived from `(outPoint - inPoint) / frameRate`.
- */
-export declare function assembleScene(ir: IRComposition, collector: ECSCollector, processedItems: ProcessedItem[], duration?: number): JSONScene;

package/dist/ir2ge/builders/animation.d.ts

@@ -1,12 +0,0 @@
-import type { IRComposition, IRLayerNode } from '@vvfx/animation-ir';
-import type { LayerProcessingContext, TransformAnimation } from '../types';
-export declare function buildTransformAnimation(layer: IRLayerNode, ctx: LayerProcessingContext): TransformAnimation;
-/**
- * Encode normalized IR transform channels as GE timeline payloads without
- * consulting composition-specific passthrough data. Sibling converters use
- * this when they need the canonical curve encoding for a preserved sub-scene.
- */
-export declare function buildNormalizedTransformAnimation(layer: IRLayerNode, ctx: Pick<LayerProcessingContext, 'width' | 'height'>): TransformAnimation;
-export declare function buildColorAnimation(layer: IRLayerNode, ir: IRComposition): Record<string, unknown> | undefined;
-/** Encode normalized IR opacity as a GE color-over-lifetime payload. */
-export declare function buildNormalizedColorAnimation(layer: IRLayerNode): Record<string, unknown> | undefined;

package/dist/ir2ge/builders/bezier.d.ts

@@ -1,44 +0,0 @@
-/**
- * Converts IR keyframe-based animation data to GE BezierKeyframeValue format.
- *
- * GE BezierKeyframeValue format per keyframe:
- * - First:  [EASE_OUT(3), [t, v, out_cp_x, out_cp_y]]
- * - Middle: [EASE(1),     [in_cp_x, in_cp_y, t, v, out_cp_x, out_cp_y]]
- * - Last:   [EASE_IN(2),  [in_cp_x, in_cp_y, t, v]]
- *
- * Time is normalized to [0, 1] based on the layer's visible frame range (ip → op).
- */
-import type { IRAnimatedProperty, IRVec3 } from '@vvfx/animation-ir';
-import { type BezierKeyframeValue } from '@galacean/effects-specification';
-export interface IRToGETimeContext {
-    /** Layer visible start frame. */
-    startFrame: number;
-    /** Layer visible end frame. */
-    endFrame: number;
-}
-export interface IRPositionGEResult {
-    /** Timing curves in BezierKeyframeValue format (1D, time-domain only). */
-    curves: BezierKeyframeValue[][];
-    /** Path points per segment: [[start_x, start_y], [end_x, end_y]]. */
-    pathPoints: [[number, number], [number, number]][];
-    /** Spatial control points per segment: [[to_x, to_y], [ti_x, ti_y]]. */
-    controlPoints: [[number, number], [number, number]][];
-}
-/**
- * Convert a 1D animated property (opacity / rotation) to GE BezierKeyframeValue[][].
- * Returns a single-element outer array with the full curve.
- */
-export declare function irScalarKeyframesToGE(property: IRAnimatedProperty<number>, timeContext: IRToGETimeContext): BezierKeyframeValue[][] | undefined;
-/**
- * Convert a multi-dimensional animated property (scale / anchor) to GE BezierKeyframeValue[][].
- * Returns one curve per dimension in the outer array.
- */
-export declare function irVectorKeyframesToGE(property: IRAnimatedProperty<IRVec3>, timeContext: IRToGETimeContext): BezierKeyframeValue[][] | undefined;
-/**
- * Convert position keyframes to GE path animation format (pp/cp + timing curves).
- */
-export declare function irPositionKeyframesToGE(property: IRAnimatedProperty<IRVec3>, timeContext: IRToGETimeContext): IRPositionGEResult | undefined;
-/**
- * Determine if a property has enough keyframes to warrant keyframe mode (pkf/skf/rkf/okf).
- */
-export declare function shouldUseKeyframeMode(property: IRAnimatedProperty): boolean;

package/dist/ir2ge/builders/component.d.ts

@@ -1,13 +0,0 @@
-import type { IRComposition, IRLayerNode, IRShapeData } from '@vvfx/animation-ir';
-import type { LayerProcessingContext } from '../types';
-export declare function buildComponent(layer: IRLayerNode, itemId: string, anchorScaleX: number, anchorScaleY: number, ctx: LayerProcessingContext): string | undefined;
-/**
- * Copy the raw GE mask object (from specific.effects passthrough) onto a freshly
- * built component, as a top-level `mask` field matching GE's structure. For a
- * mask SOURCE this carries `{isMask:true, alphaMaskEnabled}`; for a TARGET it
- * carries `{isMask:false, reference, inverted}` where `reference.id` is still
- * the stale GE1 component id — `applyGEMaskRemap` rewrites it in post-process.
- * No-op for non-GE sources (Lottie masks go through the IRLayerNode.mask path).
- */
-export declare function applyGEMask(ir: IRComposition, layer: IRLayerNode, component: Record<string, unknown>): void;
-export declare function buildShapeOptions(shapeData: IRShapeData, ratio: number, ctx?: LayerProcessingContext): Record<string, unknown>;

package/dist/ir2ge/builders/effects.d.ts

@@ -1,9 +0,0 @@
-import { type IRBlendMode } from '@vvfx/animation-ir';
-import type { DataPath } from '@galacean/effects-specification';
-import type { ECSCollector, GETransform } from '../types';
-export { estimateTextWidth } from '../utils';
-export declare function buildGETransform(position: [number, number, number], eulerHint: [number, number, number], scale: [number, number, number]): GETransform;
-export declare function getGEItemType(type: string): string;
-export declare function getGEItemTypeCode(type: string): string;
-export declare function registerTexture(collector: ECSCollector, imageUrl: string, cache: Map<string, DataPath>): DataPath;
-export declare function mapBlendingMode(blendMode: IRBlendMode | undefined): number | undefined;

package/dist/ir2ge/builders/layer.d.ts

@@ -1,6 +0,0 @@
-import type { IRLayerNode } from '@vvfx/animation-ir';
-import type { LayerProcessingContext } from '../types';
-export declare function processNullLayer(layer: IRLayerNode, ctx: LayerProcessingContext): void;
-export declare function processPrecompLayer(layer: IRLayerNode, ctx: LayerProcessingContext): void;
-export declare function processParentLayer(layer: IRLayerNode, ctx: LayerProcessingContext): void;
-export declare function processVisualLayer(layer: IRLayerNode, ctx: LayerProcessingContext): void;

package/dist/ir2ge/builders/timeline.d.ts

@@ -1,9 +0,0 @@
-import type { ECSCollector, TransformAnimation } from '../types';
-/**
- * Build the ObjectBindingTrack + Activation/Transform/SpriteColor child tracks
- * for one VFX item. Shared by lottie2ge and dsl2ge generators.
- *
- * The SpriteColor track is omitted for null layers (itemType `'null'` or
- * the GE numeric code `'3'`).
- */
-export declare function buildTimelineTracks(collector: ECSCollector, delay: number, duration: number, endBehavior: number, animation: TransformAnimation, itemType: string): string;

package/dist/ir2ge/builders/timing.d.ts

@@ -1,17 +0,0 @@
-import type { IRLayerNode } from '@vvfx/animation-ir';
-/**
- * Map an IR layer's time range to GE delay/duration in seconds, applying
- * the time-stretch and offset semantics from `IRTimeContext`.
- *
- * dsl-source IRs leave `stretch` and `offsetFrame` undefined, in which case
- * this collapses to `delay = (startFrame - compositionInPoint) / fr` and
- * `duration = (endFrame - startFrame) / fr` — exactly what dsl2ge used to
- * compute inline.
- *
- * Zero/negative durations are clamped to a 0.0001 epsilon so GE keeps the
- * activation track alive for the (degenerate) layer.
- */
-export declare function computeLayerTiming(layer: IRLayerNode, frameRate: number, compositionInPoint?: number): {
-    delay: number;
-    layerDuration: number;
-};