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

package/dist/ge2ir/converter.d.ts

@@ -1,3 +1,3 @@
-import { type IRComposition } from '@vvfx/animation-ir';
+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/index.d.ts

@@ -15,4 +15,5 @@ export { estimateTextWidth, roundNumber, lerp, createId, toDataPath } from './ir
 export { irScalarKeyframesToGE, irVectorKeyframesToGE, irPositionKeyframesToGE, shouldUseKeyframeMode, } from './ir2ge/builders/bezier';
 export type { IRToGETimeContext, IRPositionGEResult } from './ir2ge/builders/bezier';
 export { buildTimelineTracks } from './ir2ge/builders/timeline';
+export { buildNormalizedColorAnimation, buildNormalizedTransformAnimation, } from './ir2ge/builders/animation';
 export { normalizeChildVisibilityByParentDelays } from './ir2ge/post-process/visibility';

package/dist/index.js

@@ -3,7 +3,7 @@
  * Description: Galacean Effects and animation IR bidirectional conversion package
  * Author: Ant Group CO., Ltd.
  * Contributors: 澄弈
- * Version: v0.0.1-beta.6
+ * Version: v0.0.1-beta.7
  */
 
 'use strict';
@@ -1746,11 +1746,9 @@ function getTimeContext(layer) {
 }
 
 function buildTransformAnimation(layer, ctx) {
-    var transform = layer.transform;
-    if (transform == null) {
+    if (layer.transform == null) {
         return {};
     }
-    var timeContext = getTimeContext(layer);
     // Passthrough: ge2ir stores raw animation data in specific.effects to bypass the
     // IR keyframe conversion pipeline. Raw GE data is used verbatim when
     // available; otherwise the standard IR → GE conversion runs.
@@ -1758,15 +1756,32 @@ function buildTransformAnimation(layer, ctx) {
     var passthroughPosition = effectsSpecific == null ? void 0 : effectsSpecific.positionOverLifetime;
     var passthroughRotation = effectsSpecific == null ? void 0 : effectsSpecific.rotationOverLifetime;
     var passthroughSize = effectsSpecific == null ? void 0 : effectsSpecific.sizeOverLifetime;
-    var positionOverLifetime = passthroughPosition != null ? passthroughPosition : buildPositionAnim(layer, transform, timeContext, ctx);
-    var rotationOverLifetime = passthroughRotation != null ? passthroughRotation : buildRotationAnim(transform, timeContext);
-    var sizeOverLifetime = passthroughSize != null ? passthroughSize : buildSizeAnim(transform, timeContext);
+    var normalized = buildNormalizedTransformAnimation(layer, ctx);
+    var positionOverLifetime = passthroughPosition != null ? passthroughPosition : normalized.positionOverLifetime;
+    var rotationOverLifetime = passthroughRotation != null ? passthroughRotation : normalized.rotationOverLifetime;
+    var sizeOverLifetime = passthroughSize != null ? passthroughSize : normalized.sizeOverLifetime;
     return {
         positionOverLifetime: positionOverLifetime,
         rotationOverLifetime: rotationOverLifetime,
         sizeOverLifetime: sizeOverLifetime
     };
 }
+/**
+ * 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.
+ */ function buildNormalizedTransformAnimation(layer, ctx) {
+    var transform = layer.transform;
+    if (transform == null) {
+        return {};
+    }
+    var timeContext = getTimeContext(layer);
+    return {
+        positionOverLifetime: buildPositionAnim(layer, transform, timeContext, ctx),
+        rotationOverLifetime: buildRotationAnim(transform, timeContext),
+        sizeOverLifetime: buildSizeAnim(transform, timeContext)
+    };
+}
 function buildPositionAnim(layer, transform, timeContext, ctx) {
     var _posResult_curves_;
     var _posResult_pathPoints_;
@@ -1974,6 +1989,9 @@ function buildColorAnimation(layer, ir) {
     if (passthroughColor != null) {
         return passthroughColor;
     }
+    return buildNormalizedColorAnimation(layer);
+}
+/** Encode normalized IR opacity as a GE color-over-lifetime payload. */ function buildNormalizedColorAnimation(layer) {
     var transform = layer.transform;
     if ((transform == null ? void 0 : transform.opacity) == null) {
         return undefined;
@@ -5686,7 +5704,6 @@ function convertGEToIR(scene, options) {
 }
 function parseItemToLayer(item, itemId, index, ctx) {
     var _item_name, _item_visible, _ref, _item_delay, _ref1, _item_duration, _ref2;
-    var _item_transform;
     var name = (_item_name = item['name']) != null ? _item_name : "layer_" + index;
     var GEType = item['type'];
     var visible = (_item_visible = item['visible']) != null ? _item_visible : true;
@@ -5716,6 +5733,14 @@ function parseItemToLayer(item, itemId, index, ctx) {
     }
     // Parse transforms
     var itemTransform = item['transform'];
+    var itemSize = readItemSize(itemTransform);
+    var textBounds = type === 'text' && itemSize == null ? readTextBounds(componentData == null ? void 0 : componentData.text) : undefined;
+    var localBounds = itemSize != null ? {
+        x: 0,
+        y: 0,
+        width: itemSize.x / ctx.ratio,
+        height: itemSize.y / ctx.ratio
+    } : textBounds;
     var transform;
     if (itemTransform != null) {
         var staticChannels = parseStaticTransform(itemTransform, ctx);
@@ -5782,90 +5807,75 @@ function parseItemToLayer(item, itemId, index, ctx) {
             rawColorOverLifetime = col;
         }
     }
-    // Anchor from component — default to center (0.5, 0.5) when not explicitly set
-    if (type !== 'null') {
-        var _item_transform1;
-        var itemSize = (_item_transform1 = item['transform']) == null ? void 0 : _item_transform1['size'];
-        if (itemSize != null) {
-            var _ref3;
-            var layerWidth = itemSize.x / ctx.ratio;
-            var layerHeight = itemSize.y / ctx.ratio;
-            var anchorScale = (_ref3 = componentData == null ? void 0 : componentData.anchorScale) != null ? _ref3 : [
-                0.5,
-                0.5
+    // Anchor from component — default to center (0.5, 0.5) when not explicitly set.
+    // Some GE text has no transform.size, so its bounds come from TextComponent.options.
+    // The anchor itself still follows the same normalized renderer coordinates as every
+    // other visual layer; text alignment and glyph baseline are renderer-internal details.
+    if (type !== 'null' && localBounds != null) {
+        var _ref3;
+        var layerWidth = localBounds.width;
+        var layerHeight = localBounds.height;
+        var anchorScale = (_ref3 = componentData == null ? void 0 : componentData.anchorScale) != null ? _ref3 : [
+            0.5,
+            0.5
+        ];
+        var anchorInfo = reverseGenericAnchor(anchorScale, layerWidth, layerHeight);
+        var anchorX = anchorInfo.anchorX, anchorY = anchorInfo.anchorY, anchorOffsetX = anchorInfo.anchorOffsetX, anchorOffsetY = anchorInfo.anchorOffsetY;
+        if (transform == null) {
+            transform = {};
+        }
+        transform.anchor = {
+            keyframed: false,
+            value: [
+                anchorX,
+                anchorY,
+                0
+            ]
+        };
+        // Reverse the position adjustments ir2ge's processVisualLayer re-applies
+        // for non-centered anchors, so they don't double-apply on round-trip.
+        // Forward order (in 2D-px equivalent): pos += anchorOffset (computeStaticPosition),
+        // then pos += scaleAdjust (applyScalePositionAdjust). We subtract both.
+        var pos = transform.position;
+        if (pos != null && !pos.keyframed && pos.value != null) {
+            var _scale_, _scale_1;
+            var _transform_scale;
+            // scaleAdjust (only when static scale != 1 and anchor off-center by >0.5px):
+            //   3D: x += anchorDiffX*(1-sx)*ratio ; y -= anchorDiffY*(1-sy)*ratio
+            // In 2D-px (÷ratio, y-axis flips sign): x2d += anchorDiffX*(1-sx) ;
+            //   y2d += anchorDiffY*(1-sy)   (the two sign flips cancel).
+            var scale = ((_transform_scale = transform.scale) == null ? void 0 : _transform_scale.keyframed) === false && Array.isArray(transform.scale.value) ? transform.scale.value : [
+                1,
+                1,
+                1
             ];
-            var anchorX = anchorScale[0] * layerWidth;
-            var anchorY = anchorScale[1] * layerHeight;
-            if (transform == null) {
-                transform = {};
+            var sx = (_scale_ = scale[0]) != null ? _scale_ : 1;
+            var sy = (_scale_1 = scale[1]) != null ? _scale_1 : 1;
+            var anchorDiffX = anchorX - layerWidth / 2;
+            var anchorDiffY = anchorY - layerHeight / 2;
+            var anchorOffCenter = Math.abs(anchorDiffX) > 0.5 || Math.abs(anchorDiffY) > 0.5;
+            var hasStaticScale = !(sx === 1 && sy === 1);
+            var scaleAdjustX = 0;
+            var scaleAdjustY = 0;
+            if (hasStaticScale && anchorOffCenter && layerWidth > 0 && layerHeight > 0) {
+                scaleAdjustX = anchorDiffX * (1 - sx);
+                scaleAdjustY = anchorDiffY * (1 - sy);
             }
-            transform.anchor = {
-                keyframed: false,
-                value: [
-                    anchorX,
-                    anchorY,
-                    0
-                ]
-            };
-            // Reverse the position adjustments ir2ge's processVisualLayer re-applies
-            // for non-centered anchors, so they don't double-apply on round-trip.
-            // Forward order (in 2D-px equivalent): pos += anchorOffset (computeStaticPosition),
-            // then pos += scaleAdjust (applyScalePositionAdjust). We subtract both.
-            var pos = transform.position;
-            if (pos != null && !pos.keyframed && pos.value != null) {
-                var _scale_, _scale_1;
-                var _transform_scale;
-                // anchorOffset = -(anchor - size/2), added to the raw 2D position.
-                var anchorOffsetX = -(anchorX - layerWidth / 2);
-                var anchorOffsetY = -(anchorY - layerHeight / 2);
-                // scaleAdjust (only when static scale != 1 and anchor off-center by >0.5px):
-                //   3D: x += anchorDiffX*(1-sx)*ratio ; y -= anchorDiffY*(1-sy)*ratio
-                // In 2D-px (÷ratio, y-axis flips sign): x2d += anchorDiffX*(1-sx) ;
-                //   y2d += anchorDiffY*(1-sy)   (the two sign flips cancel).
-                var scale = ((_transform_scale = transform.scale) == null ? void 0 : _transform_scale.keyframed) === false && Array.isArray(transform.scale.value) ? transform.scale.value : [
-                    1,
-                    1,
-                    1
-                ];
-                var sx = (_scale_ = scale[0]) != null ? _scale_ : 1;
-                var sy = (_scale_1 = scale[1]) != null ? _scale_1 : 1;
-                var anchorDiffX = anchorX - layerWidth / 2;
-                var anchorDiffY = anchorY - layerHeight / 2;
-                var anchorOffCenter = Math.abs(anchorDiffX) > 0.5 || Math.abs(anchorDiffY) > 0.5;
-                var hasStaticScale = !(sx === 1 && sy === 1);
-                var scaleAdjustX = 0;
-                var scaleAdjustY = 0;
-                if (hasStaticScale && anchorOffCenter && layerWidth > 0 && layerHeight > 0) {
-                    scaleAdjustX = anchorDiffX * (1 - sx);
-                    scaleAdjustY = anchorDiffY * (1 - sy);
-                }
-                var totalX = anchorOffsetX + scaleAdjustX;
-                var totalY = anchorOffsetY + scaleAdjustY;
-                if (Math.abs(totalX) > 1e-6 || Math.abs(totalY) > 1e-6) {
-                    var _pos_value_;
-                    transform.position = {
-                        keyframed: false,
-                        value: [
-                            pos.value[0] - totalX,
-                            pos.value[1] - totalY,
-                            (_pos_value_ = pos.value[2]) != null ? _pos_value_ : 0
-                        ]
-                    };
-                }
+            var totalX = anchorOffsetX + scaleAdjustX;
+            var totalY = anchorOffsetY + scaleAdjustY;
+            if (Math.abs(totalX) > 1e-6 || Math.abs(totalY) > 1e-6) {
+                var _pos_value_;
+                transform.position = {
+                    keyframed: false,
+                    value: [
+                        pos.value[0] - totalX,
+                        pos.value[1] - totalY,
+                        (_pos_value_ = pos.value[2]) != null ? _pos_value_ : 0
+                    ]
+                };
             }
         }
     }
-    // Layer-local bounds from item transform.size
-    var localBounds;
-    var itemSize1 = (_item_transform = item['transform']) == null ? void 0 : _item_transform['size'];
-    if (itemSize1 != null && itemSize1.x > 0 && itemSize1.y > 0) {
-        localBounds = {
-            x: 0,
-            y: 0,
-            width: itemSize1.x / ctx.ratio,
-            height: itemSize1.y / ctx.ratio
-        };
-    }
     var text = (componentData == null ? void 0 : componentData.text) == null ? undefined : _extends({}, componentData.text);
     var solidColor = type === 'solid' ? (_ref2 = componentData == null ? void 0 : componentData.solidColor) != null ? _ref2 : [
         1,
@@ -5952,6 +5962,38 @@ function cloneJson(value) {
 function isRecord(value) {
     return value != null && (typeof value === "undefined" ? "undefined" : _type_of(value)) === 'object' && !Array.isArray(value);
 }
+function readItemSize(itemTransform) {
+    var size = itemTransform == null ? void 0 : itemTransform['size'];
+    if (!isRecord(size)) {
+        return undefined;
+    }
+    var x = size['x'];
+    var y = size['y'];
+    return typeof x === 'number' && Number.isFinite(x) && x > 0 && typeof y === 'number' && Number.isFinite(y) && y > 0 ? {
+        x: x,
+        y: y
+    } : undefined;
+}
+function readTextBounds(text) {
+    var width = text == null ? void 0 : text.width;
+    var height = text == null ? void 0 : text.height;
+    return typeof width === 'number' && Number.isFinite(width) && width > 0 && typeof height === 'number' && Number.isFinite(height) && height > 0 ? {
+        x: 0,
+        y: 0,
+        width: width,
+        height: height
+    } : undefined;
+}
+function reverseGenericAnchor(anchorScale, width, height) {
+    var anchorX = anchorScale[0] * width;
+    var anchorY = anchorScale[1] * height;
+    return {
+        anchorX: anchorX,
+        anchorY: anchorY,
+        anchorOffsetX: -(anchorX - width / 2),
+        anchorOffsetY: -(anchorY - height / 2)
+    };
+}
 
 /**
  * Read-side accessors for the `IRLayerNode.specific.lottie` slot.
@@ -5970,6 +6012,8 @@ exports.DEFAULT_CAMERA_FOV = DEFAULT_CAMERA_FOV;
 exports.DEFAULT_CAMERA_Z = DEFAULT_CAMERA_Z;
 exports.DEFAULT_CLIP_MODE = DEFAULT_CLIP_MODE;
 exports.assembleScene = assembleScene;
+exports.buildNormalizedColorAnimation = buildNormalizedColorAnimation;
+exports.buildNormalizedTransformAnimation = buildNormalizedTransformAnimation;
 exports.buildTimelineTracks = buildTimelineTracks;
 exports.convert2dTo3dPoint = convert2dTo3dPoint;
 exports.convertGEToIR = convertGEToIR;