Merge branch 'v3.8.2' into v3.8.2-pipeline

# Conflicts:
#	cocos/render-scene/scene/submodel.ts

cocos/2d/renderer/batcher-2d.ts

@@ -490,8 +490,15 @@ export class Batcher2D implements IBatcher {
      * @param mat - The material used
      * @param enableBatch - component support multi draw batch or not
      */
-    public commitMiddleware (comp: UIRenderer, meshBuffer: MeshBuffer, indexOffset: number,
-        indexCount: number, tex: TextureBase, mat: Material, enableBatch: boolean): void {
+    public commitMiddleware (
+        comp: UIRenderer,
+        meshBuffer: MeshBuffer,
+        indexOffset: number,
+        indexCount: number,
+        tex: TextureBase,
+        mat: Material,
+        enableBatch: boolean,
+    ): void {
         // check if need merge draw batch
         const texture = tex.getGFXTexture();
         if (enableBatch && this._middlewareEnableBatch && this._middlewareBuffer === meshBuffer
@@ -654,7 +661,7 @@ export class Batcher2D implements IBatcher {
         this._currBID = -1;
 
         // Request ia failed
-        if (!ia) {
+        if (!ia || !this._currTexture) {
             return;
         }
 
@@ -671,7 +678,7 @@ export class Batcher2D implements IBatcher {
 
         const curDrawBatch = this._currStaticRoot ? this._currStaticRoot._requireDrawBatch() : this._drawBatchPool.alloc();
         curDrawBatch.visFlags = this._currLayer;
-        curDrawBatch.texture = this._currTexture!;
+        curDrawBatch.texture = this._currTexture;
         curDrawBatch.sampler = this._currSampler;
         curDrawBatch.inputAssembler = ia;
         curDrawBatch.useLocalData = this._currTransform;

cocos/input/input.ts

@@ -25,9 +25,9 @@
 */
 
 import { EDITOR_NOT_IN_PREVIEW, NATIVE } from 'internal:constants';
-import { TouchInputSource, MouseInputSource, KeyboardInputSource, AccelerometerInputSource, GamepadInputDevice, HandleInputDevice, HMDInputDevice, HandheldInputDevice } from 'pal/input';
+import { AccelerometerInputSource, GamepadInputDevice, HMDInputDevice, HandheldInputDevice, HandleInputDevice, KeyboardInputSource, MouseInputSource, TouchInputSource } from 'pal/input';
 import { touchManager } from '../../pal/input/touch-manager';
-import { sys, EventTarget } from '../core';
+import { EventTarget, error, sys } from '../core';
 import { Event, EventAcceleration, EventGamepad, EventHandle, EventHandheld, EventHMD, EventKeyboard, EventMouse, EventTouch, Touch } from './types';
 import { InputEventType } from './types/event-enum';
 
@@ -62,7 +62,7 @@ class InputEventDispatcher implements IEventDispatcher {
     }
 }
 
-const pointerEventTypeMap: Record<string, string> = {
+const pointerEventTypeMap: Record<string, InputEventType> = {
     [InputEventType.MOUSE_DOWN]: InputEventType.TOUCH_START,
     [InputEventType.MOUSE_MOVE]: InputEventType.TOUCH_MOVE,
     [InputEventType.MOUSE_UP]: InputEventType.TOUCH_END,
@@ -160,28 +160,40 @@ export class Input {
     /**
      * This should be a private method, but it's exposed for Editor Only.
      */
-    private _dispatchMouseDownEvent (nativeMouseEvent: any): void { this._mouseInput.dispatchMouseDownEvent?.(nativeMouseEvent); }
+    private _dispatchMouseDownEvent (nativeMouseEvent: any): void {
+        this._mouseInput.dispatchMouseDownEvent?.(nativeMouseEvent);
+    }
     /**
      * This should be a private method, but it's exposed for Editor Only.
      */
-    private _dispatchMouseMoveEvent (nativeMouseEvent: any): void { this._mouseInput.dispatchMouseMoveEvent?.(nativeMouseEvent); }
+    private _dispatchMouseMoveEvent (nativeMouseEvent: any): void {
+        this._mouseInput.dispatchMouseMoveEvent?.(nativeMouseEvent);
+    }
     /**
      * This should be a private method, but it's exposed for Editor Only.
      */
-    private _dispatchMouseUpEvent (nativeMouseEvent: any): void { this._mouseInput.dispatchMouseUpEvent?.(nativeMouseEvent); }
+    private _dispatchMouseUpEvent (nativeMouseEvent: any): void {
+        this._mouseInput.dispatchMouseUpEvent?.(nativeMouseEvent);
+    }
     /**
      * This should be a private method, but it's exposed for Editor Only.
      */
-    private _dispatchMouseScrollEvent (nativeMouseEvent: any): void { this._mouseInput.dispatchScrollEvent?.(nativeMouseEvent); }
+    private _dispatchMouseScrollEvent (nativeMouseEvent: any): void {
+        this._mouseInput.dispatchScrollEvent?.(nativeMouseEvent);
+    }
 
     /**
      * This should be a private method, but it's exposed for Editor Only.
      */
-    private _dispatchKeyboardDownEvent (nativeKeyboardEvent: any): void { this._keyboardInput.dispatchKeyboardDownEvent?.(nativeKeyboardEvent); }
+    private _dispatchKeyboardDownEvent (nativeKeyboardEvent: any): void {
+        this._keyboardInput.dispatchKeyboardDownEvent?.(nativeKeyboardEvent);
+    }
     /**
      * This should be a private method, but it's exposed for Editor Only.
      */
-    private _dispatchKeyboardUpEvent (nativeKeyboardEvent: any): void { this._keyboardInput.dispatchKeyboardUpEvent?.(nativeKeyboardEvent); }
+    private _dispatchKeyboardUpEvent (nativeKeyboardEvent: any): void {
+        this._keyboardInput.dispatchKeyboardUpEvent?.(nativeKeyboardEvent);
+    }
 
     /**
      * @en
@@ -229,6 +241,37 @@ export class Input {
         }
         this._eventTarget.off(eventType, callback, target);
     }
+
+    /**
+     * @en
+     * Get touch object by touch ID.
+     * @zh
+     * 通过 touch ID 获取 touch对象。
+     */
+    public getTouch (touchID: number): Readonly<Touch> | undefined {
+        return touchManager.getTouch(touchID);
+    }
+
+    /**
+     * @en
+     * Get all the current touches objects as array.
+     * @zh
+     * 获取当前 所有touch对象 的数组。
+     */
+    public getAllTouches (): Touch[] {
+        return touchManager.getAllTouches();
+    }
+
+    /**
+     * @en
+     * Get the number of touches.
+     * @zh
+     * 获取当前 touch 对象的数量。
+     */
+    public getTouchCount (): number {
+        return touchManager.getTouchCount();
+    }
+
     /**
      * @en
      * Sets whether to enable the accelerometer event listener or not.
@@ -264,7 +307,7 @@ export class Input {
     private _simulateEventTouch (eventMouse: EventMouse): void {
         const eventType = pointerEventTypeMap[eventMouse.type];
         const touchID = 0;
-        const touch = touchManager.getTouch(touchID, eventMouse.getLocationX(), eventMouse.getLocationY());
+        const touch = touchManager.getOrCreateTouch(touchID, eventMouse.getLocationX(), eventMouse.getLocationY());
         if (!touch) {
             return;
         }
@@ -295,19 +338,27 @@ export class Input {
                     break;
                 }
             } catch (e) {
-                console.error(`Error occurs in an event listener: ${event.type}`);
-                console.error(e);
+                error(`Error occurs in an event listener: ${event.type}`);
+                error(e);
             }
         }
     }
 
     private _registerEvent (): void {
         if (sys.hasFeature(sys.Feature.INPUT_TOUCH)) {
             const eventTouchList = this._eventTouchList;
-            this._touchInput.on(InputEventType.TOUCH_START, (event): void => { this._dispatchOrPushEventTouch(event, eventTouchList); });
-            this._touchInput.on(InputEventType.TOUCH_MOVE, (event): void => { this._dispatchOrPushEventTouch(event, eventTouchList); });
-            this._touchInput.on(InputEventType.TOUCH_END, (event): void => { this._dispatchOrPushEventTouch(event, eventTouchList); });
-            this._touchInput.on(InputEventType.TOUCH_CANCEL, (event): void => { this._dispatchOrPushEventTouch(event, eventTouchList); });
+            this._touchInput.on(InputEventType.TOUCH_START, (event): void => {
+                this._dispatchOrPushEventTouch(event, eventTouchList);
+            });
+            this._touchInput.on(InputEventType.TOUCH_MOVE, (event): void => {
+                this._dispatchOrPushEventTouch(event, eventTouchList);
+            });
+            this._touchInput.on(InputEventType.TOUCH_END, (event): void => {
+                this._dispatchOrPushEventTouch(event, eventTouchList);
+            });
+            this._touchInput.on(InputEventType.TOUCH_CANCEL, (event): void => {
+                this._dispatchOrPushEventTouch(event, eventTouchList);
+            });
         }
 
         if (sys.hasFeature(sys.Feature.EVENT_MOUSE)) {
@@ -328,42 +379,66 @@ export class Input {
                 this._simulateEventTouch(event);
                 this._dispatchOrPushEvent(event, eventMouseList);
             });
-            this._mouseInput.on(InputEventType.MOUSE_WHEEL, (event): void => { this._dispatchOrPushEvent(event, eventMouseList); });
+            this._mouseInput.on(InputEventType.MOUSE_WHEEL, (event): void => {
+                this._dispatchOrPushEvent(event, eventMouseList);
+            });
         }
 
         if (sys.hasFeature(sys.Feature.EVENT_KEYBOARD)) {
             const eventKeyboardList = this._eventKeyboardList;
-            this._keyboardInput.on(InputEventType.KEY_DOWN, (event): void => { this._dispatchOrPushEvent(event, eventKeyboardList); });
-            this._keyboardInput.on(InputEventType.KEY_PRESSING, (event): void => { this._dispatchOrPushEvent(event, eventKeyboardList); });
-            this._keyboardInput.on(InputEventType.KEY_UP, (event): void => { this._dispatchOrPushEvent(event, eventKeyboardList); });
+            this._keyboardInput.on(InputEventType.KEY_DOWN, (event): void => {
+                this._dispatchOrPushEvent(event, eventKeyboardList);
+            });
+            this._keyboardInput.on(InputEventType.KEY_PRESSING, (event): void => {
+                this._dispatchOrPushEvent(event, eventKeyboardList);
+            });
+            this._keyboardInput.on(InputEventType.KEY_UP, (event): void => {
+                this._dispatchOrPushEvent(event, eventKeyboardList);
+            });
         }
 
         if (sys.hasFeature(sys.Feature.EVENT_ACCELEROMETER)) {
             const eventAccelerationList = this._eventAccelerationList;
-            this._accelerometerInput.on(InputEventType.DEVICEMOTION, (event): void => { this._dispatchOrPushEvent(event, eventAccelerationList); });
+            this._accelerometerInput.on(InputEventType.DEVICEMOTION, (event): void => {
+                this._dispatchOrPushEvent(event, eventAccelerationList);
+            });
         }
 
         if (sys.hasFeature(sys.Feature.EVENT_GAMEPAD)) {
             const eventGamepadList = this._eventGamepadList;
-            GamepadInputDevice._on(InputEventType.GAMEPAD_CHANGE, (event): void => { this._dispatchOrPushEvent(event, eventGamepadList); });
-            GamepadInputDevice._on(InputEventType.GAMEPAD_INPUT, (event): void => { this._dispatchOrPushEvent(event, eventGamepadList); });
-            GamepadInputDevice._on(InputEventType.HANDLE_POSE_INPUT, (event): void => { this._dispatchOrPushEvent(event, eventGamepadList); });
+            GamepadInputDevice._on(InputEventType.GAMEPAD_CHANGE, (event): void => {
+                this._dispatchOrPushEvent(event, eventGamepadList);
+            });
+            GamepadInputDevice._on(InputEventType.GAMEPAD_INPUT, (event): void => {
+                this._dispatchOrPushEvent(event, eventGamepadList);
+            });
+            GamepadInputDevice._on(InputEventType.HANDLE_POSE_INPUT, (event): void => {
+                this._dispatchOrPushEvent(event, eventGamepadList);
+            });
         }
 
         if (sys.hasFeature(sys.Feature.EVENT_HANDLE)) {
             const eventHandleList = this._eventHandleList;
-            this._handleInput._on(InputEventType.HANDLE_INPUT, (event): void => { this._dispatchOrPushEvent(event, eventHandleList); });
-            this._handleInput._on(InputEventType.HANDLE_POSE_INPUT, (event): void => { this._dispatchOrPushEvent(event, eventHandleList); });
+            this._handleInput._on(InputEventType.HANDLE_INPUT, (event): void => {
+                this._dispatchOrPushEvent(event, eventHandleList);
+            });
+            this._handleInput._on(InputEventType.HANDLE_POSE_INPUT, (event): void => {
+                this._dispatchOrPushEvent(event, eventHandleList);
+            });
         }
 
         if (sys.hasFeature(sys.Feature.EVENT_HMD)) {
             const eventHMDList = this._eventHMDList;
-            this._hmdInput._on(InputEventType.HMD_POSE_INPUT, (event): void => { this._dispatchOrPushEvent(event, eventHMDList); });
+            this._hmdInput._on(InputEventType.HMD_POSE_INPUT, (event): void => {
+                this._dispatchOrPushEvent(event, eventHMDList);
+            });
         }
 
         if (sys.hasFeature(sys.Feature.EVENT_HANDHELD)) {
             const eventHandheldList = this._eventHandheldList;
-            this._handheldInput._on(InputEventType.HANDHELD_POSE_INPUT, (event): void => { this._dispatchOrPushEvent(event, eventHandheldList); });
+            this._handheldInput._on(InputEventType.HANDHELD_POSE_INPUT, (event): void => {
+                this._dispatchOrPushEvent(event, eventHandheldList);
+            });
         }
     }
 

cocos/input/types/event-enum.ts

@@ -265,7 +265,7 @@ export enum SystemEventType {
      * @en The event type for node's sibling order changed.
      * @zh 当节点在兄弟节点中的顺序发生变化时触发的事件。
      *
-     * @deprecated since v3.3, please use Node.EventType.SIBLING_ORDER_CHANGED instead
+     * @deprecated since v3.3, please use Node.EventType.CHILDREN_ORDER_CHANGED instead
      */
     SIBLING_ORDER_CHANGED = 'sibling-order-changed',
 }

cocos/input/types/touch.ts

@@ -199,7 +199,7 @@ export class Touch {
 
         _vec2.set(this._point);
         _vec2.subtract(this._prevPoint);
-        out.set(cclegacy.view.getScaleX(), cclegacy.view.getScaleY());
+        out.set(cclegacy.view.getScaleX() as number, cclegacy.view.getScaleY() as number);
         Vec2.divide(out, _vec2, out);
         return out;
     }
@@ -261,7 +261,7 @@ export class Touch {
      * @param x - x position of the touch point
      * @param y - y position of the touch point
      */
-    public setTouchInfo (id = 0, x?: number, y?: number): void {
+    public setTouchInfo (id: number = 0, x: number = 0, y: number = 0): void {
         this._prevPoint = this._point;
         this._point = new Vec2(x || 0, y || 0);
         this._id = id;
@@ -321,6 +321,21 @@ export class Touch {
         }
         this._lastModified = cclegacy.game.frameStartTime;
     }
+
+    /**
+     * @zh Touch 对象的原始数据不应该被修改。如果你需要这么做，最好克隆一个新的对象。
+     * @en The original Touch object shouldn't be modified. If you need to, it's better to clone a new one.
+     */
+    public clone (): Touch {
+        const touchID = this.getID();
+        this.getStartLocation(_vec2);
+        const clonedTouch = new Touch(_vec2.x, _vec2.y, touchID);
+        this.getLocation(_vec2);
+        clonedTouch.setPoint(_vec2.x, _vec2.y);
+        this.getPreviousLocation(_vec2);
+        clonedTouch.setPrevPoint(_vec2);
+        return clonedTouch;
+    }
 }
 
 cclegacy.Touch = Touch;

cocos/physics/utils/util.ts

@@ -22,7 +22,7 @@
  THE SOFTWARE.
 */
 
-import { equals, Vec3, IVec3Like } from '../../core';
+import { equals, Vec3, IVec3Like, murmurhash2_32_gc } from '../../core';
 import { CharacterController, CharacterTriggerEventType, Collider, CollisionEventType, IContactEquation, TriggerEventType } from '../framework';
 
 export { cylinder } from '../../primitive';
@@ -69,23 +69,21 @@ export const CollisionEventObject = {
 
 export function shrinkPositions (buffer: Float32Array | number[]): number[] {
     const pos: number[] = [];
+    const posHashMap = {};
     if (buffer.length >= 3) {
-        // eslint-disable-next-line no-unused-expressions
-        pos[0] = buffer[0], pos[1] = buffer[1], pos[2] = buffer[2];
+        pos[0] = buffer[0];
+        pos[1] = buffer[1];
+        pos[2] = buffer[2];
         const len = buffer.length;
         for (let i = 3; i < len; i += 3) {
             const p0 = buffer[i];
             const p1 = buffer[i + 1];
             const p2 = buffer[i + 2];
-            const len2 = pos.length;
-            let isNew = true;
-            for (let j = 0; j < len2; j += 3) {
-                if (equals(p0, pos[j]) && equals(p1, pos[j + 1]) && equals(p2, pos[j + 2])) {
-                    isNew = false;
-                    break;
-                }
-            }
-            if (isNew) {
+            const str = String(p0) +  String(p1) + String(p2);
+            //todo: directly use buffer as input
+            const hash = murmurhash2_32_gc(str, 666);
+            if (posHashMap[hash] !== str) {
+                posHashMap[hash] = str;
                 pos.push(p0); pos.push(p1); pos.push(p2);
             }
         }