packages/ui/src/component/UITransform.ts (1)

183-185: Improve null safety for child transform updates

The optional chaining on line 184 could skip updates silently. Consider adding explicit null checks.

    for (let i = 0, n = children.length; i < n; i++) {
-      (children[i].transform as unknown as UITransform)?._calAbsoluteByRelative();
+      const childTransform = children[i].transform;
+      if (childTransform instanceof UITransform) {
+        childTransform._calAbsoluteByRelative();
+      }
    }

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

packages/ui/src/component/UITransform.ts (4)

78-89: Fix property assignment - use private fields instead of setters.

Line 83 incorrectly uses the public setter. Use the private fields directly.

-    this._left = this.right = NaN;
+    this._left = this._right = NaN;

---

129-140: Fix property assignment - use private fields instead of setters.

Line 134 incorrectly uses the public setter. Use the private fields directly.

-    this._top = this.bottom = NaN;
+    this._top = this._bottom = NaN;

---

267-269: Critical: Fix incorrect bitshift operator usage.

Line 268 incorrectly uses the bitshift right operator >> instead of division. This will produce incorrect results.

 case UITransformAlignment.Center:
-  position.x = (parentRect.x + (parentRect.width - localRect.width)) >> (1 + localRect.x + this._center);
+  position.x = parentRect.x + (parentRect.width - localRect.width) / 2 + localRect.x + this._center;
   break;

---

284-286: Critical: Fix incorrect bitshift operator usage.

Line 285 has the same bitshift operator issue as line 268.

 case UITransformAlignment.Middle:
-  position.y = (parentRect.y + (parentRect.height - localRect.height)) >> (1 + localRect.y + this._middle);
+  position.y = parentRect.y + (parentRect.height - localRect.height) / 2 + localRect.y + this._middle;
   break;

packages/ui/src/component/UITransform.ts (6)

22-28: Remove redundant double-negation.

The double-negation is unnecessary since numeric values are automatically coerced to boolean in conditional contexts.

 override get position(): Vector3 {
-  if (this._isContainDirtyFlag(UITransformModifyFlags.LocalPosition) && !!this._alignment) {
+  if (this._isContainDirtyFlag(UITransformModifyFlags.LocalPosition) && this._alignment) {
     this._calAbsoluteByAlignment();
     this._setDirtyFlagFalse(UITransformModifyFlags.LocalPosition);
   }
   return this._position;
 }

---

30-38: Remove redundant double-negation in matrix setters.

 override set localMatrix(value: Matrix) {
   super.localMatrix = value;
-  !!this._alignment && this._setDirtyFlagTrue(UITransformModifyFlags.LpLm);
+  this._alignment && this._setDirtyFlagTrue(UITransformModifyFlags.LpLm);
 }

 override set worldMatrix(value: Matrix) {
   super.worldMatrix = value;
-  !!this._alignment && this._setDirtyFlagTrue(UITransformModifyFlags.LpLmWm);
+  this._alignment && this._setDirtyFlagTrue(UITransformModifyFlags.LpLmWm);
 }

---

190-202: Remove redundant double-negation.

 protected override _parentChange(): void {
   super._parentChange();
   const alignment = this._alignment;
-  if (!!alignment) {
+  if (alignment) {
     this._setDirtyFlagTrue(UITransformModifyFlags.LocalPosition);
     if (
       (alignment & UITransformAlignment.Horizontal) === UITransformAlignment.LeftAndRight ||
       (alignment & UITransformAlignment.Vertical) === UITransformAlignment.TopAndBottom
     ) {
       this._setLocalRectDirty(UITransformModifyFlags.LsLr);
     }
   }
 }

---

204-224: Remove redundant double-negation in alignment setters.

 private _setHorizontalAlignment(value: UITransformAlignment): void {
   const alignment = this._alignment;
   if ((alignment & UITransformAlignment.Horizontal) != value) {
     this._alignment = (alignment & UITransformAlignment.Vertical) | value;
-    if (!!value) {
+    if (value) {
       this._onPositionChanged();
       value === UITransformAlignment.LeftAndRight && this._onSizeChanged();
     }
   }
 }

 private _setVerticalAlignment(value: UITransformAlignment): void {
   const alignment = this._alignment;
   if ((alignment & UITransformAlignment.Vertical) != value) {
     this._alignment = (alignment & UITransformAlignment.Horizontal) | value;
-    if (!!value) {
+    if (value) {
       this._onPositionChanged();
       value === UITransformAlignment.TopAndBottom && this._onSizeChanged();
     }
   }
 }

---

237-254: Remove redundant double-negation.

 private _setLocalRectDirty(flags: UITransformModifyFlags): void {
   if (this._isContainDirtyFlag(flags)) return;
   this._setDirtyFlagTrue(flags);
   const children = this.entity.children;
   for (let i = 0, n = children.length; i < n; i++) {
     const transform = children[i].transform as unknown as UITransform;
     const alignment = transform?._alignment ?? UITransformAlignment.None;
-    if (!!alignment) {
+    if (alignment) {
       transform._setDirtyFlagTrue(UITransformModifyFlags.LocalPosition);
       if (
         (alignment & UITransformAlignment.Horizontal) === UITransformAlignment.LeftAndRight ||
         (alignment & UITransformAlignment.Vertical) === UITransformAlignment.TopAndBottom
       ) {
         transform._setLocalRectDirty(UITransformModifyFlags.LsLr);
       }
     }
   }
 }

---

304-313: Remove redundant double-negation in position handlers.

 @ignoreClone
 protected override _onPositionChanged(): void {
   super._onPositionChanged();
-  !!this._alignment && this._setDirtyFlagTrue(UITransformModifyFlags.LocalPosition);
+  this._alignment && this._setDirtyFlagTrue(UITransformModifyFlags.LocalPosition);
 }

 @ignoreClone
 protected override _onWorldPositionChanged(): void {
   super._onWorldPositionChanged();
-  !!this._alignment && this._setDirtyFlagTrue(UITransformModifyFlags.WorldPosition);
+  this._alignment && this._setDirtyFlagTrue(UITransformModifyFlags.WorldPosition);
 }

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

packages/ui/src/component/UITransform.ts (1)

25-25: Remove redundant double-negation for cleaner code.

The static analysis correctly identifies redundant double-negation operators. In boolean contexts (if statements, logical operators), explicit boolean coercion is unnecessary:

-        if (!!parentRect) {
+        if (parentRect) {

-        if (!!this._alignment) {
+        if (this._alignment) {

Apply similar changes to all flagged instances for more readable code.

Also applies to: 103-103, 135-135, 304-304, 317-317, 325-325, 349-349, 364-364, 374-374

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

packages/ui/src/component/UITransform.ts (10)

25-25: Remove redundant double-negation.

The double-negation operator is unnecessary here since the expression will already be coerced to a boolean in the conditional context.

-      if (!!parentRect) {
+      if (parentRect) {

---

103-103: Remove redundant double-negation.

The double-negation operator is unnecessary here.

-    if (!!this._alignment) {
+    if (this._alignment) {

---

135-135: Remove redundant double-negation.

The double-negation operator is unnecessary here.

-    if (!!this._alignment) {
+    if (this._alignment) {

---

186-186: Fix formatting issue.

There's a formatting issue that needs to be addressed for better readability.

-      this._left = this._right = NaN;
+      this._left = this._right = NaN;

---

237-237: Fix formatting issue.

There's a formatting issue that needs to be addressed for better readability.

-      this._top = this._bottom = NaN;
+      this._top = this._bottom = NaN;

---

304-304: Remove redundant double-negation.

The double-negation operator is unnecessary here.

-    if (!!alignment) {
+    if (alignment) {

---

317-317: Remove redundant double-negation.

The double-negation operator is unnecessary here.

-    if (!!value) {
+    if (value) {

---

325-325: Remove redundant double-negation.

The double-negation operator is unnecessary here.

-    if (!!value) {
+    if (value) {

---

349-349: Remove redundant double-negation.

The double-negation operator is unnecessary here.

-      if (!!alignment) {
+      if (alignment) {

---

364-364: Remove redundant double-negation.

The double-negation operator is unnecessary here.

-    if (!!this._alignment) {
+    if (this._alignment) {

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

packages/ui/src/component/UITransform.ts (4)

22-71: Fix redundant double-negation and approve the alignment logic

The position calculation logic is well-implemented with proper handling of different alignment cases and performance optimizations. However, there's a redundant double-negation on line 25.

Apply this diff to remove the redundant double-negation:

-      if (!!parentRect) {
+      if (parentRect) {

---

72-141: Fix redundant double-negations and approve matrix handling

The matrix override implementations are sophisticated and correctly handle the complex relationship between local/world matrices and UI alignment. The dirty flag management and callback handling are well-designed.

Apply these diffs to remove redundant double-negations:

-    if (!!this._alignment) {
+    if (this._alignment) {

-    if (!!this._alignment) {
+    if (this._alignment) {

---

292-377: Fix redundant double-negations and approve lifecycle management

The constructor and lifecycle method overrides are well-implemented. The parent change handling correctly manages dirty flags for alignment-aware transforms, and the callback binding ensures proper reactivity.

Apply these diffs to remove redundant double-negations:

-    if (!!alignment) {
+    if (alignment) {

-    if (!!this._alignment) {
+    if (this._alignment) {

---

317-398: Fix redundant double-negations and approve helper methods

The private helper methods are well-designed and implement the core alignment system effectively. The recursive dirty flag propagation and local rect caching are good optimizations.

Apply these diffs to remove redundant double-negations:

-    if (!!value) {
+    if (value) {

-    if (!!value) {
+    if (value) {

-      if (!!alignment) {
+      if (alignment) {

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

packages/ui/src/component/UITransform.ts (7)

25-25: Remove redundant double-negation.

The double-negation is unnecessary as the value will be coerced to boolean in the conditional context.

-      if (!!parentRect) {
+      if (parentRect) {

---

103-103: Remove redundant double-negation.

Simplify the boolean check for better readability.

-    if (!!this._alignment) {
+    if (this._alignment) {

---

135-135: Remove redundant double-negation.

Simplify the boolean check for consistency.

-    if (!!this._alignment) {
+    if (this._alignment) {

---

311-311: Remove redundant double-negation.

Simplify the boolean check for better readability.

-      if (!!alignment) {
+      if (alignment) {

---

338-338: Remove redundant double-negation.

Simplify the boolean check for consistency.

-    if (!!value) {
+    if (value) {

---

346-346: Remove redundant double-negation.

Simplify the boolean check for consistency.

-    if (!!value) {
+    if (value) {

---

382-382: Remove redundant double-negation.

Simplify the boolean check for consistency.

-    if (!!this._alignment) {
+    if (this._alignment) {

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

packages/ui/src/component/UITransform.ts (3)

22-70: Excellent alignment-aware position implementation with minor cleanup needed.

The position getter correctly implements sophisticated alignment calculations with proper dirty flag management and callback handling. The position setter is appropriately simplified for the alignment system.

Fix the redundant double-negation flagged by static analysis:

-      if (!!parentRect) {
+      if (parentRect) {

---

72-140: Robust matrix handling with alignment awareness.

The matrix property overrides correctly implement alignment-aware transform management with proper dirty flag handling and parent-child relationships.

Fix redundant double-negations flagged by static analysis:

-    if (!!this._alignment) {
+    if (this._alignment) {
      this._setDirtyFlagTrue(UITransformModifyFlags.LmLp);
    } else {
      this._setDirtyFlagFalse(UITransformModifyFlags.LmLp);
    }

-    if (!!this._alignment) {
+    if (this._alignment) {
      this._setDirtyFlagTrue(UITransformModifyFlags.WorldMatrix);
    } else {
      this._setDirtyFlagFalse(UITransformModifyFlags.WorldMatrix);
    }

---

303-396: Solid override implementations for alignment-aware transform lifecycle.

The method overrides correctly handle alignment state changes and dirty flag propagation throughout the transform hierarchy.

Fix redundant double-negations flagged by static analysis:

-      if (!!alignment) {
+      if (alignment) {

-    if (!!value) {
+    if (value) {

-    if (!!value) {
+    if (value) {

-    if (!!this._alignment) {
+    if (this._alignment) {

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

packages/ui/src/component/UITransform.ts (3)

22-64: Remove redundant double-negation.

The position calculation logic is correct, but line 25 has redundant double-negation that can be simplified.

-      if (!!parentRect) {
+      if (parentRect) {

---

72-140: Remove redundant double-negations in matrix methods.

The matrix override logic is correct, but there are redundant double-negations that can be simplified.

-    if (!!this._alignment) {
+    if (this._alignment) {
      this._setDirtyFlagTrue(UITransformModifyFlags.LmLp);
    } else {
      this._setDirtyFlagFalse(UITransformModifyFlags.LmLp);
    }

-    if (!!this._alignment) {
+    if (this._alignment) {
      this._setDirtyFlagTrue(UITransformModifyFlags.WorldMatrix);
    } else {
      this._setDirtyFlagFalse(UITransformModifyFlags.WorldMatrix);
    }

---

303-428: Remove redundant double-negations in private methods.

The private method implementations are logically correct, but several instances of redundant double-negation can be simplified for cleaner code.

-      if (!!alignment) {
+      if (alignment) {

-    if (!!value) {
+    if (value) {

-    if (!!value) {
+    if (value) {

-    !!this._alignment && this._setDirtyFlagTrue(UITransformModifyFlags.WorldPosition);
+    this._alignment && this._setDirtyFlagTrue(UITransformModifyFlags.WorldPosition);

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

packages/ui/src/component/UITransform.ts (6)

22-64: Remove redundant double-negation in parent rectangle check.

The alignment-aware position calculation logic is well-implemented, but line 25 contains redundant double-negation as flagged by static analysis.

-      if (!!parentRect) {
+      if (parentRect) {

The mathematical calculations for different alignment cases appear correct, and the temporary disabling of value change callbacks prevents recursive updates.

---

72-108: Remove redundant double-negation in alignment check.

The matrix computation and decomposition logic is correct, but line 103 contains redundant double-negation.

-    if (!!this._alignment) {
+    if (this._alignment) {

The alignment-aware dirty flag management is a good addition to handle layout recalculations when matrices change.

---

110-140: Remove redundant double-negation in alignment check.

The world matrix computation is correctly implemented with proper parent hierarchy handling, but line 135 contains redundant double-negation.

-    if (!!this._alignment) {
+    if (this._alignment) {

The matrix inversion and local matrix update logic is sound.

---

303-337: Remove redundant double-negation in alignment check.

The hierarchy change propagation logic is well-implemented but line 311 contains redundant double-negation.

-      if (!!alignment) {
+      if (alignment) {

The _transferFlags method correctly handles:

• Conditional flag propagation based on alignment state
• Special handling for stretched alignment modes
• Efficient dirty flag containment checks to avoid unnecessary work
• Recursive propagation to child transforms

This is essential for maintaining layout consistency across the UI hierarchy.

---

339-380: Remove redundant double-negations in alignment checks.

The alignment helper methods are well-structured but contain redundant double-negations flagged by static analysis.

-    if (!!value) {
+    if (value) {

Apply this fix to both lines 341 and 349.

The helper methods provide excellent abstractions:

• Clean separation of horizontal and vertical alignment management
• Proper triggering of position and size recalculations when needed
• Efficient cached rectangle computation in _getLocalRect
• Sound bitwise operations for flag isolation

---

383-428: Remove redundant double-negation in alignment check.

The event handler overrides are correctly implemented but line 385 contains redundant double-negation.

-    if (!!this._alignment) {
+    if (this._alignment) {

The event handlers properly integrate with the alignment system:

• Position change handlers manage alignment-specific dirty flags appropriately
• Size and pivot handlers trigger necessary recalculations
• Proper update flag manager dispatching for change notifications
• Efficient recursive propagation to child transforms

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

tests/src/ui/UITransform.test.ts (2)

299-302: Avoid duplicating internal flags; import enum instead

Redefining UITransformModifyFlags is brittle. Import from the package if publicly exported; otherwise assert via public APIs instead of bits.

-enum UITransformModifyFlags {
-  Size = 0x200,
-  Pivot = 0x400
-}
+import { UITransformModifyFlags } from "@galacean/engine-ui";

---

10-22: Refactor: don’t use async describe; move setup into beforeAll/afterAll

Async describe causes tests to register unreliably in Vitest. Move async work to hooks and clean up the engine to prevent leaks.

-import { describe, expect, it } from "vitest";
+import { beforeAll, afterAll, describe, expect, it } from "vitest";
@@
-describe("UITransform", async () => {
-  const canvas = document.createElement("canvas");
-  const engine = await WebGLEngine.create({ canvas });
-  const webCanvas = engine.canvas;
-  webCanvas.width = 750;
-  webCanvas.height = 1334;
-  const scene = engine.sceneManager.scenes[0];
-  const root = scene.createRootEntity("root");
-
-  // Parent with UITransform (via UICanvas), children created under it will inherit UITransform automatically
-  const canvasEntity = root.createChild("canvas");
-  canvasEntity.addComponent(UICanvas);
+describe("UITransform", () => {
+  let engine: WebGLEngine;
+  let root: any;
+  let canvasEntity: any;
+
+  beforeAll(async () => {
+    const canvas = document.createElement("canvas");
+    engine = await WebGLEngine.create({ canvas });
+    const webCanvas = engine.canvas;
+    webCanvas.width = 750;
+    webCanvas.height = 1334;
+    const scene = engine.sceneManager.scenes[0];
+    root = scene.createRootEntity("root");
+    canvasEntity = root.createChild("canvas");
+    canvasEntity.addComponent(UICanvas);
+  });
+
+  afterAll(async () => {
+    await engine?.destroy?.();
+  });

packages/core/src/Transform.ts (1)

642-651: Guard Matrix.invert in world→local mapping

Same singular-matrix issue when writing worldPosition.

-    if (parent) {
-      Matrix.invert(parent.worldMatrix, Transform._tempMat41);
-      Vector3.transformCoordinate(worldPosition, Transform._tempMat41, this._position);
-    } else {
+    if (parent) {
+      const inv = Matrix.invert(parent.worldMatrix, Transform._tempMat41);
+      if (inv) {
+        Vector3.transformCoordinate(worldPosition, inv, this._position);
+      } else {
+        this._position.copyFrom(worldPosition);
+      }
+    } else {
       this._position.copyFrom(worldPosition);
     }

tests/src/ui/UITransform.test.ts (2)

2-7: Style: fix prettier import formatting

Match repo prettier: collapse named imports to a single line.

-import {
-  HorizontalAlignmentFlags,
-  UICanvas,
-  UITransform,
-  VerticalAlignmentFlags,
-} from "@galacean/engine-ui";
+import { HorizontalAlignmentFlags, UICanvas, UITransform, VerticalAlignmentFlags } from "@galacean/engine-ui";

---

275-277: Style: remove extra blank lines

Prettier flags these empty lines.

-
-
-

packages/ui/src/component/UITransform.ts (2)

261-266: Re-setting WorldPosition dirty in _onWorldPositionChanged can loop

Calling super clears the flag; setting it true again may cause extra churn. If the goal is to notify dependents, prefer _worldAssociatedChange gating instead of raw dirty bit.

-    if (!!this._horizontalAlignment || !!this._verticalAlignment) {
-      this._setDirtyFlagTrue(UITransformModifyFlags.WorldPosition);
-    }
+    // If notification is needed, gate by containment to avoid churn:
+    // if (!this._isContainDirtyFlag(UITransformModifyFlags.WorldPosition)) {
+    //   this._worldAssociatedChange(UITransformModifyFlags.WorldPosition);
+    // }

---

403-417: Avoid duplicating core flags in UITransformModifyFlags

These values mirror TransformModifyFlags and can drift. Reuse core flags and only add UI-specific ones (Size, Pivot).

-import {
-  Entity,
-  MathUtil,
-  Matrix,
-  Quaternion,
-  Rect,
-  Transform,
-  Vector2,
-  Vector3,
-  deepClone,
-  ignoreClone
-} from "@galacean/engine";
+import {
+  Entity,
+  MathUtil,
+  Matrix,
+  Quaternion,
+  Rect,
+  Transform,
+  TransformModifyFlags as TMF,
+  Vector2,
+  Vector3,
+  deepClone,
+  ignoreClone
+} from "@galacean/engine";
@@
-export enum UITransformModifyFlags {
-  None = 0x0,
-  LocalEuler = 0x1,
-  LocalQuat = 0x2,
-  WorldPosition = 0x4,
-  LocalMatrix = 0x40,
-  WorldMatrix = 0x80,
-  Size = 0x200,
-  Pivot = 0x400,
-
-  /** World matrix | world position. */
-  WmWp = WorldMatrix | WorldPosition,
-  /** WorldMatrix | WorldPosition | WorldEuler | WorldQuat | WorldScale | WorldUniformScaling */
-  WmWpWeWqWsWus = 0x1bc
-}
+export enum UITransformModifyFlags {
+  None = TMF.WmWp & ~TMF.WmWp, // 0
+  // Reuse core bits:
+  LocalEuler = TMF.LocalEuler,
+  LocalQuat = TMF.LocalQuat,
+  WorldPosition = TMF.WorldPosition,
+  LocalMatrix = TMF.LocalMatrix,
+  WorldMatrix = TMF.WorldMatrix,
+  // UI-specific:
+  Size = 0x200,
+  Pivot = 0x400,
+  // Common combos:
+  WmWp = TMF.WmWp,
+  WmWpWeWqWsWus = TMF.WmWpWeWqWsWus
+}

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: cptbtptpbcptdtptp
PR: galacean/engine#2760
File: packages/ui/src/component/UITransform.ts:0-0
Timestamp: 2025-08-26T08:22:31.028Z
Learning: In UITransform, when there is a relative layout (alignment-based positioning), it has higher priority than absolute layout (direct position setting). This means that setting position directly while alignment is active should be overridden by the alignment calculations, which is the intended behavior.

Learnt from: cptbtptpbcptdtptp
PR: galacean/engine#2760
File: packages/ui/src/component/UITransform.ts:0-0
Timestamp: 2025-08-26T08:22:31.028Z
Learning: In UITransform, when there is a relative layout (alignment-based positioning), it has higher priority than absolute layout (direct position setting). This means that setting position directly while alignment is active should be overridden by the alignment calculations, which is the intended behavior.

packages/core/src/Transform.ts (1)

642-653: Also guard invert in world→local position mapping

Unprotected inversion can propagate NaNs when the parent is non-invertible. Same concern previously raised.

Apply:

   const parent = this._getParentTransform();
   if (parent) {
-    Matrix.invert(parent.worldMatrix, Transform._tempMat41);
-    Vector3.transformCoordinate(worldPosition, Transform._tempMat41, this._position);
+    const inv = Matrix.invert(parent.worldMatrix, Transform._tempMat41);
+    if (inv) {
+      Vector3.transformCoordinate(worldPosition, inv, this._position);
+    } else {
+      this._position.copyFrom(worldPosition);
+    }
   } else {
     this._position.copyFrom(worldPosition);
   }
   this._setDirtyFlagFalse(TransformModifyFlags.WorldPosition);

packages/ui/src/component/UITransform.ts (1)

1-14: Stop duplicating core Transform flags; reference them

UITransformModifyFlags redefines core bits (LocalMatrix, WorldMatrix, etc.). This is brittle if core values change. Reference core flags directly and reserve UI-only bits for Size/Pivot.

Apply:

-import {
-  Entity,
-  MathUtil,
-  Matrix,
-  Quaternion,
-  Rect,
-  Transform,
-  Vector2,
-  Vector3,
-  deepClone,
-  ignoreClone
-} from "@galacean/engine";
+import {
+  Entity,
+  MathUtil,
+  Matrix,
+  Quaternion,
+  Rect,
+  Transform,
+  TransformModifyFlags as TMF,
+  Vector2,
+  Vector3,
+  deepClone,
+  ignoreClone
+} from "@galacean/engine";
@@
 export enum UITransformModifyFlags {
-  None = 0x0,
-  LocalEuler = 0x1,
-  LocalQuat = 0x2,
-  WorldPosition = 0x4,
-  LocalMatrix = 0x40,
-  WorldMatrix = 0x80,
-  Size = 0x200,
-  Pivot = 0x400,
-
-  /** World matrix | world position. */
-  WmWp = WorldMatrix | WorldPosition,
-  /** WorldMatrix | WorldPosition | WorldEuler | WorldQuat | WorldScale | WorldUniformScaling */
-  WmWpWeWqWsWus = 0x1bc
+  None = 0x0,
+  // Reuse core flags
+  LocalEuler = TMF.LocalEuler,
+  LocalQuat = TMF.LocalQuat,
+  WorldPosition = TMF.WorldPosition,
+  LocalMatrix = TMF.LocalMatrix,
+  WorldMatrix = TMF.WorldMatrix,
+  // UI-only flags
+  Size = 0x200,
+  Pivot = 0x400,
+  // Reuse core composites
+  WmWp = TMF.WmWp,
+  WmWpWeWqWsWus = TMF.WmWpWeWqWsWus
 }

Also applies to: 403-417

packages/core/src/Transform.ts (1)

616-634: Minor: simplify parent lookup

Every Entity has a transform; the loop that skips entities without transforms can be simplified for maintainability.

-    let parentCache: Transform = null;
-    let parent = this._entity.parent;
-    while (parent) {
-      const transform = parent.transform;
-      if (transform) {
-        parentCache = transform;
-        break;
-      } else {
-        parent = parent.parent;
-      }
-    }
+    let parentCache: Transform = null;
+    let parent = this._entity.parent;
+    if (parent) parentCache = parent.transform;

packages/ui/src/component/UITransform.ts (1)

55-59: Clamp pivot to [0, 1]

Out-of-range pivots yield surprising rects. Clamp for robustness.

  set pivot(value: Vector2) {
    const { _pivot: pivot } = this;
    if (pivot === value) return;
-    (pivot.x !== value.x || pivot.y !== value.y) && pivot.copyFrom(value);
+    if (pivot.x !== value.x || pivot.y !== value.y) {
+      pivot.set(MathUtil.clamp(value.x, 0, 1), MathUtil.clamp(value.y, 0, 1));
+    }
  }

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: cptbtptpbcptdtptp
PR: galacean/engine#2760
File: packages/ui/src/component/UITransform.ts:0-0
Timestamp: 2025-08-26T08:22:31.028Z
Learning: In UITransform, when there is a relative layout (alignment-based positioning), it has higher priority than absolute layout (direct position setting). This means that setting position directly while alignment is active should be overridden by the alignment calculations, which is the intended behavior.

Learnt from: cptbtptpbcptdtptp
PR: galacean/engine#2760
File: packages/ui/src/component/UITransform.ts:0-0
Timestamp: 2025-08-26T08:22:31.028Z
Learning: In UITransform, when there is a relative layout (alignment-based positioning), it has higher priority than absolute layout (direct position setting). This means that setting position directly while alignment is active should be overridden by the alignment calculations, which is the intended behavior.

packages/core/src/Transform.ts (1)

642-653: Also guard inversion in world→local position mapping.

Apply:

-    if (parent) {
-      Matrix.invert(parent.worldMatrix, Transform._tempMat41);
-      Vector3.transformCoordinate(worldPosition, Transform._tempMat41, this._position);
-    } else {
+    if (parent) {
+      const inv = Matrix.invert(parent.worldMatrix, Transform._tempMat41);
+      if (inv) {
+        Vector3.transformCoordinate(worldPosition, inv, this._position);
+      } else {
+        this._position.copyFrom(worldPosition);
+      }
+    } else {
       this._position.copyFrom(worldPosition);
     }

packages/ui/src/component/UITransform.ts (3)

255-261: Short-circuit worldPosition writes under active alignment to reduce churn.

Avoid doing world→local then immediately overriding via alignment and re-dirtying WorldPosition.

Apply:

-  protected override _onWorldPositionChanged(): void {
-    super._onWorldPositionChanged();
-    if (!!this._horizontalAlignment || !!this._verticalAlignment) {
-      this._setDirtyFlagTrue(UITransformModifyFlags.WorldPosition);
-    }
-  }
+  protected override _onWorldPositionChanged(): void {
+    if (this._horizontalAlignment || this._verticalAlignment) {
+      // Ignore external world-position writes when relative layout is active.
+      this._calPosition();
+      this._setDirtyFlagFalse(UITransformModifyFlags.WorldPosition);
+      return;
+    }
+    super._onWorldPositionChanged();
+  }

---

303-319: Clamp comment vs. behavior mismatch.

Comment says “must be greater than 0” but code clamps to >= 0. Align the comment to “non-negative” or clamp to a tiny epsilon.

Apply either:

-      // The values of size must be greater than 0.
+      // The values of size must be non-negative.

or

-        size.x = Math.max(parentRect.width - this._left - this._right, 0);
+        size.x = Math.max(parentRect.width - this._left - this._right, 1e-6);

(and similarly for size.y)

---

398-412: Deduplicate flag values by reusing core TransformModifyFlags.

Prevents silent drift if core bits change.

Apply:

@@
-import {
+import {
   Entity,
   MathUtil,
   Matrix,
   Quaternion,
   Rect,
   Transform,
+  TransformModifyFlags as TMF,
   Vector2,
   Vector3,
   deepClone,
   ignoreClone
 } from "@galacean/engine";
@@
 export enum UITransformModifyFlags {
   None = 0x0,
-  LocalEuler = 0x1,
-  LocalQuat = 0x2,
-  WorldPosition = 0x4,
-  LocalMatrix = 0x40,
-  WorldMatrix = 0x80,
+  LocalEuler = TMF.LocalEuler,
+  LocalQuat = TMF.LocalQuat,
+  WorldPosition = TMF.WorldPosition,
+  LocalMatrix = TMF.LocalMatrix,
+  WorldMatrix = TMF.WorldMatrix,
   Size = 0x200,
   Pivot = 0x400,
   /** World matrix | world position. */
-  WmWp = WorldMatrix | WorldPosition,
+  WmWp = TMF.WmWp,
   /** WorldMatrix | WorldPosition | WorldEuler | WorldQuat | WorldScale | WorldUniformScaling */
-  WmWpWeWqWsWus = 0x1bc
+  WmWpWeWqWsWus = TMF.WmWpWeWqWsWus
 }

Also applies to: 1-12

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: cptbtptpbcptdtptp
PR: galacean/engine#2760
File: packages/ui/src/component/UITransform.ts:0-0
Timestamp: 2025-08-26T08:22:31.028Z
Learning: In UITransform, when there is a relative layout (alignment-based positioning), it has higher priority than absolute layout (direct position setting). This means that setting position directly while alignment is active should be overridden by the alignment calculations, which is the intended behavior.

Learnt from: cptbtptpbcptdtptp
PR: galacean/engine#2760
File: packages/ui/src/component/UITransform.ts:0-0
Timestamp: 2025-08-26T08:22:31.028Z
Learning: In UITransform, when there is a relative layout (alignment-based positioning), it has higher priority than absolute layout (direct position setting). This means that setting position directly while alignment is active should be overridden by the alignment calculations, which is the intended behavior.

packages/ui/src/component/UITransform.ts (7)

68-85: Canonicalize horizontalAlignment to supported combos

Prevent illegal mixes (e.g., Left|Center) from becoming a silent no-op by normalizing to None | Left | Center | Right | LeftAndRight before applying side effects.

   set horizontalAlignment(value: HorizontalAlignmentFlags) {
-    const current = this._horizontalAlignment;
-    if (current === value) return;
-    this._horizontalAlignment = value;
-    switch (value) {
+    // Canonicalize: only allow None | Left | Center | Right | LeftAndRight
+    const LR = HorizontalAlignmentFlags.Left | HorizontalAlignmentFlags.Right;
+    const allowed = HorizontalAlignmentFlags.Left | HorizontalAlignmentFlags.Right | HorizontalAlignmentFlags.Center;
+    let v = value & allowed;
+    if ((v & LR) === LR) v = HorizontalAlignmentFlags.LeftAndRight;
+    else if ((v & HorizontalAlignmentFlags.Center) && (v & LR)) v = HorizontalAlignmentFlags.Center;
+    if (v === 0) v = HorizontalAlignmentFlags.None;
+
+    const current = this._horizontalAlignment;
+    if (current === v) return;
+    this._horizontalAlignment = v;
+    switch (v) {
       case HorizontalAlignmentFlags.Left:
       case HorizontalAlignmentFlags.Right:
       case HorizontalAlignmentFlags.Center:
         this._onPositionChanged();
         break;
       case HorizontalAlignmentFlags.LeftAndRight:
         this._onPositionChanged();
         this._onSizeChanged();
         break;
       default:
         break;
     }
   }

---

142-159: Canonicalize verticalAlignment to supported combos

Normalize to None | Top | Middle | Bottom | TopAndBottom to avoid undefined behavior with mixed flags.

   set verticalAlignment(value: VerticalAlignmentFlags) {
-    const current = this._verticalAlignment;
-    if (current === value) return;
-    this._verticalAlignment = value;
-    switch (value) {
+    // Canonicalize: only allow None | Top | Middle | Bottom | TopAndBottom
+    const TB = VerticalAlignmentFlags.Top | VerticalAlignmentFlags.Bottom;
+    const allowed = VerticalAlignmentFlags.Top | VerticalAlignmentFlags.Bottom | VerticalAlignmentFlags.Middle;
+    let v = value & allowed;
+    if ((v & TB) === TB) v = VerticalAlignmentFlags.TopAndBottom;
+    else if ((v & VerticalAlignmentFlags.Middle) && (v & TB)) v = VerticalAlignmentFlags.Middle;
+    if (v === 0) v = VerticalAlignmentFlags.None;
+
+    const current = this._verticalAlignment;
+    if (current === v) return;
+    this._verticalAlignment = v;
+    switch (v) {
       case VerticalAlignmentFlags.Top:
       case VerticalAlignmentFlags.Bottom:
       case VerticalAlignmentFlags.Middle:
         this._onPositionChanged();
         break;
       case VerticalAlignmentFlags.TopAndBottom:
         this._onPositionChanged();
         this._onSizeChanged();
         break;
       default:
         break;
     }
   }

---

238-243: Avoid unnecessary _calPosition when alignment is off

Minor perf/readability: guard the call; behavior unchanged.

   protected override _decomposeLocalMatrix(matrix: Matrix, pos: Vector3, quat: Quaternion, scale: Vector3): void {
     matrix.decompose(pos, quat, scale);
-    this._calPosition();
+    if (this._horizontalAlignment || this._verticalAlignment) {
+      this._calPosition();
+    }
     this._setDirtyFlagTrue(UITransformModifyFlags.LocalEuler | UITransformModifyFlags.LocalMatrix);
     this._setDirtyFlagFalse(UITransformModifyFlags.LocalQuat);
   }

---

256-261: Redundant world-position dirty flag

Base already handles world-position dirtiness; setting it again under alignment adds noise without benefit.

   protected override _onWorldPositionChanged(): void {
     super._onWorldPositionChanged();
-    if (!!this._horizontalAlignment || !!this._verticalAlignment) {
-      this._setDirtyFlagTrue(UITransformModifyFlags.WorldPosition);
-    }
   }

---

263-266: Type-narrow parentTransform instead of casting through unknown

Safer narrowing avoids accidental misuse when the parent isn’t a UITransform.

-    const parentRect = (this._getParentTransform() as unknown as UITransform)?._rect;
+    const parent = this._getParentTransform();
+    const parentRect = parent instanceof UITransform ? parent._rect : undefined;

Apply similarly in _calSize.

Also applies to: 303-306

---

309-315: Comment nit: “greater than 0” → “non-negative”

You clamp to 0, so the comment should reflect non-negativity.

-      // The values of size must be greater than 0.
+      // Size values are clamped to be non-negative.

---

401-414: Don’t duplicate core Transform flags; ensure parity or reuse

Redefining shared bits (LocalMatrix, WorldMatrix, WorldPosition, etc.) is brittle. Prefer reusing core flags or add a dev-only parity assert to catch drift early.

Option A (preferred): reuse core flags.

• Import core TransformModifyFlags and reference them where needed, keeping UI-only flags (Size, Pivot, LocalRect, LocalPosition) in this enum or as consts.

Option B: add a parity assert (dev-only) that validates your numeric values match core at startup; keep UI-only bits local.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: cptbtptpbcptdtptp
PR: galacean/engine#2760
File: packages/ui/src/component/UITransform.ts:0-0
Timestamp: 2025-08-26T08:22:31.028Z
Learning: In UITransform, when there is a relative layout (alignment-based positioning), it has higher priority than absolute layout (direct position setting). This means that setting position directly while alignment is active should be overridden by the alignment calculations, which is the intended behavior.

Learnt from: cptbtptpbcptdtptp
PR: galacean/engine#2760
File: packages/ui/src/component/UITransform.ts:0-0
Timestamp: 2025-08-26T08:22:31.028Z
Learning: In UITransform, when there is a relative layout (alignment-based positioning), it has higher priority than absolute layout (direct position setting). This means that setting position directly while alignment is active should be overridden by the alignment calculations, which is the intended behavior.

packages/ui/src/component/UITransform.ts (1)

400-414: Deduplicate core Transform flags; reuse from core or assert parity

Replicating core flag bit values is brittle. Reuse TransformModifyFlags for shared bits; keep UI-only flags locally. If reuse isn’t possible, add a dev-time parity assertion.

Preferred change:

+import { TransformModifyFlags as TMF } from "@galacean/engine";
@@
 export enum UITransformModifyFlags {
-  None = 0x0,
-  LocalEuler = 0x1,
-  LocalQuat = 0x2,
-  WorldPosition = 0x4,
-  LocalMatrix = 0x40,
-  WorldMatrix = 0x80,
+  None = 0x0,
+  LocalEuler = TMF.LocalEuler,
+  LocalQuat = TMF.LocalQuat,
+  WorldPosition = TMF.WorldPosition,
+  LocalMatrix = TMF.LocalMatrix,
+  WorldMatrix = TMF.WorldMatrix,
   Size = 0x200,
   Pivot = 0x400,
-  WmWp = WorldMatrix | WorldPosition,
-  WmWpWeWqWsWus = 0x1bc
+  WmWp = TMF.WorldMatrix | TMF.WorldPosition,
+  // Keep this composite in sync with core:
+  WmWpWeWqWsWus = TMF.WorldMatrix | TMF.WorldPosition | TMF.WorldEuler | TMF.WorldQuat | TMF.WorldScale | TMF.WorldUniformScaling
 }

Fallback (if importing TMF here causes layering issues): add a one-time dev assert at startup comparing these bit values against core.

packages/ui/src/component/UITransform.ts (3)

245-247: Prefer explicit if over boolean short-circuit for side effects

Improves readability and avoids mixing boolean expressions with a void call.

-  protected override _onWorldMatrixChange() {
-    !this._horizontalAlignment && !this._verticalAlignment && super._onWorldMatrixChange();
-  }
+  protected override _onWorldMatrixChange() {
+    if (!this._horizontalAlignment && !this._verticalAlignment) {
+      super._onWorldMatrixChange();
+    }
+  }

---

249-253: Remove @ignoreClone on methods

ignoreClone is for fields; applying it to methods is unnecessary and pollutes clone metadata.

-  @ignoreClone
   protected override _onPositionChanged(): void {
@@
-  @ignoreClone
   protected override _onWorldPositionChanged(): void {
@@
-  @ignoreClone
   private _onSizeChanged(): void {
@@
-  @ignoreClone
   private _onPivotChanged(): void {

Also applies to: 255-261, 328-340, 342-348

---

263-266: Tighten parent rect access (avoid double cast to unknown)

Minor TS hygiene; keeps the cast localized and clearer.

-    const parentRect = (this._getParentTransform() as unknown as UITransform)?._rect;
+    const parent = this._getParentTransform() as UITransform | undefined;
+    const parentRect = parent?._rect;

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: cptbtptpbcptdtptp
PR: galacean/engine#2760
File: packages/ui/src/component/UITransform.ts:0-0
Timestamp: 2025-08-26T08:22:31.028Z
Learning: In UITransform, when there is a relative layout (alignment-based positioning), it has higher priority than absolute layout (direct position setting). This means that setting position directly while alignment is active should be overridden by the alignment calculations, which is the intended behavior.

Learnt from: cptbtptpbcptdtptp
PR: galacean/engine#2760
File: packages/ui/src/component/UITransform.ts:0-0
Timestamp: 2025-08-26T08:22:31.028Z
Learning: In UITransform, when there is a relative layout (alignment-based positioning), it has higher priority than absolute layout (direct position setting). This means that setting position directly while alignment is active should be overridden by the alignment calculations, which is the intended behavior.