@ives_xxz/framework 1.4.2 → 1.4.4

package/FW.d.ts

@@ -34,6 +34,7 @@ declare namespace FW {
     engineMgr: EngineManager;
     taskMgr: TaskManager;
     hotUpdateMgr: HotUpdateManager;
+    promiseMgr: PromiseManager;
     scene: Scene;
     bundleName: string;
     getComponent<T>(serviceIdentifier: FW.ServiceIdentifier<T>): T;
@@ -48,6 +49,17 @@ declare namespace FW {
     onDestroy(): void;
   };
 
+  type PromiseManager = {
+    public execute<T = any>(
+      executor: (
+        resolve: (value: T | PromiseLike<T>) => void,
+        reject: (reason?: any) => void,
+        signal: AbortSignal,
+      ) => void = PromiseExcutor,
+      options: PromiseExecuteOptions = {},
+    ): PromiseProxy<T>;
+  };
+
   type Registry = {
     /** 注册 */
     register(): void;
@@ -1899,6 +1911,52 @@ declare namespace FW {
     message?: string;
   };
 
+  // 颜色分段配置接口
+  type AssemblerLabelColorSegment = {
+    color: cc.Color;
+    position: number;
+  };
+
+  type AssemblerLabelColorConfig = {
+    color: cc.Color;
+    percentages: number;
+  };
+
+  type PromiseProxy<T = Promise> = {
+    id: number;
+    promise: Promise<T>;
+    status: any;
+    abortController: AbortController;
+    abort?: (reason?: any) => void;
+    addAbortEventListener?: (
+      listener: (this: AbortSignal, ev: Event) => any,
+      options?: boolean | AddEventListenerOptions,
+    ) => void;
+  };
+
+  type PromiseExcutor<T> = (
+    resolve: (value: T | PromiseLike<T>) => void,
+    reject: (reason?: any) => void,
+    signal: AbortSignal,
+  ) => void;
+
+  type PromiseExecuteOptions = {
+    timeout?: number;
+    retryCount?: number;
+    retryInterval?: number;
+    retryCondition?: (error: any, retryCount: number) => boolean;
+  };
+
+  type Promise = (resolve: (value: any) => void, reject: (reason?: any) => void) => void;
+
+  type PromiseResult<T = any> = {
+    success: T[];
+    failed: { id: number; reason: any }[];
+    cancelled: number[];
+  };
+
+  type PromiseStatus = 'pending' | 'fulfilled' | 'rejected' | 'cancelled';
+
   declare function timeScale(scale: number);
   declare let Entry: Entry;
 }

package/define/FWSystemDefine.ts

@@ -130,4 +130,11 @@ export namespace FWSystemDefine {
     SPRITE = 'sprite',
     SKELETON = 'skeleton',
   }
+
+  export enum FWPromiseStatus {
+    PENDING = 'pending',
+    FULFILLED = 'fulfilled',
+    REJECTED = 'rejected',
+    CANCELLED = 'cancelled',
+  }
 }

package/entry/FWEntry.ts

@@ -18,6 +18,7 @@ import { FWEventDefine } from '../define/FWEventDefine';
 import FWTaskManager from '../manager/FWTaskManager';
 import FWEngineManager from '../manager/FWEngineManager';
 import FWHotUpdateManager from '../manager/FWHotUpdateManager';
+import FWPromiseManager from '../manager/FWPromiseManager';
 
 /**
  * 入口脚本
@@ -84,6 +85,10 @@ export default class FWEntry implements FW.Entry {
    * 热更新管理器
    */
   hotUpdateMgr: FW.HotUpdateManager;
+  /**
+   * promise管理器
+   */
+  promiseMgr: FW.PromiseManager;
   /**
    * 当前Scene
    */
@@ -113,6 +118,7 @@ export default class FWEntry implements FW.Entry {
     this.componentMgr = new FWComponentManager();
     this.languageMgr = new FWLanguageManager();
     this.hotUpdateMgr = new FWHotUpdateManager();
+    this.promiseMgr = new FWPromiseManager();
 
     this.resMgr.initialize();
     this.layerMgr.initialize();

package/manager/FWAssetManager.ts

@@ -77,6 +77,9 @@ export class FWAssetManager extends FWManager implements FW.AssetManager {
   ): Promise<T> {
     return new Promise((resolve, reject) => {
       cc.assetManager.loadRemote(url, { cacheEnabled: true, maxRetryCount: 0 }, (err, asset) => {
+        if (err || !asset) {
+          reject(err);
+        }
         cb?.(asset as T);
         resolve(asset as T);
       });
@@ -128,11 +131,8 @@ export class FWAssetManager extends FWManager implements FW.AssetManager {
 
     assetData.loaded = false;
 
-    return new Promise(
-      (
-        resolve: (value: FW.AssetData | PromiseLike<FW.AssetData>) => void,
-        reject: (reason?: any) => void,
-      ) => {
+    return FW.Entry.promiseMgr.execute(
+      (resolve, reject, signal) => {
         const self = this;
         bundle.load(
           path,
@@ -142,8 +142,11 @@ export class FWAssetManager extends FWManager implements FW.AssetManager {
           },
           (err: Error, asset: cc.Asset) => {
             if (err || !asset) {
-              FWLog.error(`加载资源失败:${asset},请检查!`);
-              reject(err);
+              signal.addEventListener('abort', () => {
+                FWLog.error(`加载资源失败:${asset},请检查!`);
+                reject(err);
+              });
+              return;
             }
 
             assetData.loaded = true;
@@ -162,7 +165,11 @@ export class FWAssetManager extends FWManager implements FW.AssetManager {
           },
         );
       },
-    );
+      {
+        timeout: 10,
+        retryCount: 3,
+      },
+    ).promise;
   }
   /**
    * 加载文件夹

package/manager/FWPromiseManager.ts

@@ -0,0 +1,244 @@
+import { FWSystemDefine } from '../define/FWSystemDefine';
+import FWLog from '../log/FWLog';
+import { FWManager } from './FWManager';
+
+export default class FWPromiseManager extends FWManager implements FW.PromiseManager {
+  private promiseRegistry: Map<number, FW.PromiseProxy>;
+  private uniqueId: number = 0;
+  private timerSchedule: FW.TimerSchedule;
+
+  public initialize(): void {
+    this.promiseRegistry = new Map<number, FW.PromiseProxy>();
+  }
+
+  public onDestroy(): void {
+    this.cancelAll('Manager destroyed');
+    this.promiseRegistry.clear();
+    this.promiseRegistry = null;
+  }
+
+  /** 创建Promise执行器 */
+  public execute<T = any>(
+    executor: FW.PromiseExcutor<T>,
+    options: FW.PromiseExecuteOptions = {},
+  ): FW.PromiseProxy<T> {
+    const id = this.uniqueId++;
+    const abortController = new AbortController();
+    let retryCount = 0;
+    let promise: Promise<T>;
+    const maxRetryTimes = options.retryCount || 0;
+    const retryInterval = options.retryInterval || 0;
+    const promiseProxy: FW.PromiseProxy<T> = {
+      id,
+      promise,
+      status: FWSystemDefine.FWPromiseStatus.PENDING,
+      abortController,
+    };
+
+    const createPromise = (): Promise<T> => {
+      return new Promise<T>((resolve, reject) => {
+        if (options.timeout && options.timeout > 0) {
+          this.timerSchedule?.unSchedule();
+          this.timerSchedule = FW.Entry.timeMgr.scheduleOnce(() => {
+            const timeoutError = new Error(`Promise ${id} timeout after ${options.timeout} s`);
+            if (
+              retryCount < maxRetryTimes &&
+              (!options.retryCondition || options.retryCondition(timeoutError, retryCount))
+            ) {
+              retryCount++;
+              FWLog.debug(`Promise ${id} timeout, retrying (${retryCount}/${maxRetryTimes})`);
+              if (retryInterval > 0) {
+                FW.Entry.timeMgr.scheduleOnce(() => {
+                  createPromise().then(resolve, reject);
+                }, retryInterval);
+              } else {
+                createPromise().then(resolve, reject);
+              }
+            } else {
+              abortController.abort(timeoutError.message);
+              this.timerSchedule?.unSchedule();
+            }
+          }, options.timeout);
+        }
+
+        const onAbort = () => {
+          this.timerSchedule?.unSchedule();
+          if (promiseProxy.status === FWSystemDefine.FWPromiseStatus.PENDING) {
+            promiseProxy.status = FWSystemDefine.FWPromiseStatus.CANCELLED;
+            this.removePromise(id);
+          }
+        };
+
+        if (abortController.signal.aborted) {
+          onAbort();
+          return;
+        }
+
+        abortController.signal.addEventListener('abort', onAbort);
+
+        const wrappedResolve = (value: T | PromiseLike<T>) => {
+          this.timerSchedule?.unSchedule();
+          if (promiseProxy.status === FWSystemDefine.FWPromiseStatus.PENDING) {
+            promiseProxy.status = FWSystemDefine.FWPromiseStatus.FULFILLED;
+            abortController.signal.removeEventListener('abort', onAbort);
+            this.removePromise(id);
+            resolve(value);
+          }
+        };
+
+        const wrappedReject = (reason?: any) => {
+          this.timerSchedule?.unSchedule();
+          if (
+            retryCount < maxRetryTimes &&
+            (!options.retryCondition || options.retryCondition(reason, retryCount))
+          ) {
+            retryCount++;
+            FWLog.debug(`Promise ${id} failed, retrying (${retryCount}/${maxRetryTimes}):`, reason);
+            if (retryInterval > 0) {
+              FW.Entry.timeMgr.scheduleOnce(() => {
+                createPromise().then(resolve, reject);
+              }, retryInterval);
+            } else {
+              createPromise().then(resolve, reject);
+            }
+          } else {
+            if (promiseProxy.status === FWSystemDefine.FWPromiseStatus.PENDING) {
+              promiseProxy.status = FWSystemDefine.FWPromiseStatus.REJECTED;
+              abortController.signal.removeEventListener('abort', onAbort);
+              this.removePromise(id);
+              reject(reason);
+            }
+          }
+        };
+        try {
+          executor(wrappedResolve, wrappedReject, abortController.signal);
+        } catch (error) {
+          wrappedReject(error);
+        }
+      });
+    };
+
+    promise = createPromise();
+    promiseProxy.abort = (reason?: any) => {
+      if (promiseProxy.status === FWSystemDefine.FWPromiseStatus.PENDING) {
+        FWLog.debug(reason || 'promise cancelled');
+        abortController.abort(reason);
+      }
+    };
+    promiseProxy.addAbortEventListener = (
+      listener: (this: AbortSignal, ev: Event) => any,
+      options?: boolean | AddEventListenerOptions,
+    ) => {
+      abortController.signal.addEventListener('abort', listener, options);
+    };
+    this.promiseRegistry.set(id, promiseProxy);
+    return promiseProxy;
+  }
+
+  /** 取消指定Promise */
+  public cancel(id: number, reason?: any): boolean {
+    const promiseProxy = this.promiseRegistry.get(id);
+    if (promiseProxy && promiseProxy.status === FWSystemDefine.FWPromiseStatus.PENDING) {
+      promiseProxy.abort(reason);
+      return true;
+    }
+    return false;
+  }
+
+  /** 批量取消Promise */
+  public cancelMultiple(ids: number[], reason?: any): number[] {
+    const cancelled: number[] = [];
+    ids.forEach((id) => {
+      if (this.cancel(id, reason)) {
+        cancelled.push(id);
+      }
+    });
+    return cancelled;
+  }
+
+  /** 取消所有Promise */
+  public cancelAll(reason?: any): number[] {
+    const cancelled: number[] = [];
+    this.promiseRegistry.forEach((promiseProxy, id) => {
+      if (promiseProxy.status === FWSystemDefine.FWPromiseStatus.PENDING) {
+        promiseProxy.abort(reason);
+        cancelled.push(id);
+      }
+    });
+    return cancelled;
+  }
+
+  /** 批量执行Promise并等待所有完成 */
+  public async all<T = any>(
+    promises: FW.PromiseProxy<T>[],
+    options: FW.PromiseExecuteOptions = {},
+  ): Promise<FW.PromiseResult<T>> {
+    const result: FW.PromiseResult<T> = {
+      success: [],
+      failed: [],
+      cancelled: [],
+    };
+
+    for (const promiseProxy of promises) {
+      try {
+        const value = await promiseProxy.promise;
+        result.success.push(value);
+      } catch (error) {
+        if (promiseProxy.status === FWSystemDefine.FWPromiseStatus.CANCELLED) {
+          result.cancelled.push(promiseProxy.id);
+        } else {
+          result.failed.push({
+            id: promiseProxy.id,
+            reason: error,
+          });
+        }
+      }
+    }
+
+    return result;
+  }
+
+  /** 获取Promise状态 */
+  public getStatus(id: number): FWSystemDefine.FWPromiseStatus | null {
+    const promiseProxy = this.promiseRegistry.get(id);
+    return promiseProxy ? promiseProxy.status : null;
+  }
+
+  /** 获取所有Promise状态 */
+  public getAllStatus(): Map<number, FWSystemDefine.FWPromiseStatus> {
+    const statusMap = new Map<number, FWSystemDefine.FWPromiseStatus>();
+    this.promiseRegistry.forEach((promiseProxy, id) => {
+      statusMap.set(id, promiseProxy.status);
+    });
+    return statusMap;
+  }
+
+  /** 移除Promise */
+  private removePromise(id: number): void {
+    this.promiseRegistry.delete(id);
+  }
+
+  /** 获取正在执行的Promise数量 */
+  public getActiveCount(): number {
+    return Array.from(this.promiseRegistry.values()).filter(
+      (p) => p.status === FWSystemDefine.FWPromiseStatus.PENDING,
+    ).length;
+  }
+
+  /** 清理已完成的Promise */
+  public clearCompletedPromise(): number {
+    const completedIds: number[] = [];
+
+    this.promiseRegistry.forEach((promiseProxy, id) => {
+      if (promiseProxy.status !== FWSystemDefine.FWPromiseStatus.PENDING) {
+        completedIds.push(id);
+      }
+    });
+
+    completedIds.forEach((id) => {
+      this.promiseRegistry.delete(id);
+    });
+
+    return completedIds.length;
+  }
+}

package/manager/FWPromiseManager.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "efe0f191-ae87-4773-9dbe-5c66f49670db",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ives_xxz/framework",
-  "version": "1.4.2",
+  "version": "1.4.4",
   "description": "cocoscreator 2.x mvc framework",
   "main": "index.js",
   "keywords": ["123456"],

package/render/FWAssembler.ts

@@ -0,0 +1,11 @@
+// Learn TypeScript:
+//  - https://docs.cocos.com/creator/manual/en/scripting/typescript.html
+// Learn Attribute:
+//  - https://docs.cocos.com/creator/manual/en/scripting/reference/attributes.html
+// Learn life-cycle callbacks:
+//  - https://docs.cocos.com/creator/manual/en/scripting/life-cycle-callbacks.html
+
+const { ccclass, property } = cc._decorator;
+
+@ccclass
+export default class FWAssembler extends cc['Assembler'] {}

package/render/FWAssembler.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "3b9ad8cf-0317-4163-bda0-17c6f4e86028",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/render/FWRenderAssembler.ts

@@ -0,0 +1,620 @@
+import { FWLodash } from '../utils/FWLodash';
+
+const { ccclass, property, executeInEditMode, menu } = cc._decorator;
+
+@ccclass('AssemblerLabelColorConfig')
+class AssemblerLabelColorConfig implements FW.AssemblerLabelColorConfig {
+  @property({ displayName: '颜色' })
+  color: cc.Color = cc.Color.WHITE;
+
+  @property({ type: cc.Float, min: 0, max: 1, displayName: '占比', slide: true })
+  percentages: number = 0;
+}
+
+@ccclass
+@executeInEditMode
+@menu('CustomComponent/FWRenderAssembler')
+export default class FWRenderAssembler extends cc.Component {
+  @property({ displayName: '文本自定义渐变色' })
+  enableLabelCustomColors: boolean = false;
+
+  @property
+  _gradientDirection: number = 0;
+  @property({
+    type: cc.Enum({ 从左到右: 0, 从上到下: 1 }),
+    displayName: '渐变方向',
+    visible() {
+      return this.enableLabelCustomColors;
+    },
+  })
+  get gradientDirection() {
+    return this._gradientDirection;
+  }
+
+  set gradientDirection(gradientDirection: number) {
+    this._gradientDirection = gradientDirection;
+    if (CC_EDITOR) {
+      this.adjustLabel();
+      this.onPropertyChanged();
+    }
+  }
+
+  @property
+  _config: AssemblerLabelColorConfig[] = [];
+
+  @property({
+    type: [AssemblerLabelColorConfig],
+    visible() {
+      return this.enableLabelCustomColors;
+    },
+    displayName: '颜色配置',
+  })
+  get config() {
+    return this._config;
+  }
+  set config(config: AssemblerLabelColorConfig[]) {
+    this._config = config;
+    if (CC_EDITOR) {
+      this.adjustLabel();
+      this.onPropertyChanged();
+    }
+  }
+
+  private _horizontalAlign: number;
+  private _verticalAlign: number;
+  private _originalRenderData: any = null;
+  private _originalUpdateRenderData: Function = null;
+  private _originalFillBuffers: Function = null;
+  private _isPatched: boolean = false;
+  private _colors: cc.Color[] = [];
+  private _percentages: number[] = [];
+  private _isOriginalDataSaved: boolean = false;
+  private _cachedProperties: any;
+
+  protected start(): void {
+    this.adjustLabel();
+    this.config.forEach((v) => {
+      this._colors.push(v.color);
+      this._percentages.push(v.percentages);
+    });
+
+    if (!CC_EDITOR) {
+      cc.director.on(cc.Director.EVENT_AFTER_DRAW, this.onUpdateAssembler, this);
+    } else {
+      this.node.on(cc.Node.EventType.SIZE_CHANGED, this.onRefreshEditor, this);
+      this.node.on(cc.Node.EventType.COLOR_CHANGED, this.onRefreshEditor, this);
+      this.node.on(cc.Node.EventType.ANCHOR_CHANGED, this.onRefreshEditor, this);
+      setTimeout(() => {
+        this.cacheLabelProperties();
+        this.onPropertyChanged();
+      });
+    }
+  }
+
+  onRefreshEditor() {
+    if (CC_EDITOR && this.enableLabelCustomColors) {
+      this._originalRenderData = null;
+      this._isOriginalDataSaved = false;
+      this.node.label['_assembler'] = null;
+      this.node.active = false;
+      this.node.active = true;
+      setTimeout(() => {
+        this.onPropertyChanged();
+      }, 30);
+    }
+  }
+
+  private refreshGradient(): void {
+    this._colors = [];
+    this._percentages = [];
+    this.config.forEach((v) => {
+      this._colors.push(v.color);
+      this._percentages.push(v.percentages);
+    });
+
+    this._isPatched = false;
+    this.onUpdateAssembler();
+  }
+
+  private cacheLabelProperties(): void {
+    const label = this.node.label;
+    if (!label) {
+      this._cachedProperties = null;
+      return;
+    }
+
+    this._cachedProperties = {
+      horizontalAlign: label.horizontalAlign,
+      verticalAlign: label.verticalAlign,
+      overflow: label.overflow,
+      enableWrap: label.enableWrapText,
+      fontFamily: label.fontFamily,
+      font: label.font ? label.font['_uuid'] : null,
+      underlineHeight: label.underlineHeight,
+      cacheMode: label.cacheMode,
+    };
+  }
+
+  private checkLabelPropertiesChanged(): boolean {
+    const label = this.node.label;
+    if (!label || !this._cachedProperties) {
+      return false;
+    }
+
+    const current = {
+      horizontalAlign: label.horizontalAlign,
+      verticalAlign: label.verticalAlign,
+      overflow: label.overflow,
+      enableWrap: label.enableWrapText,
+      underlineHeight: label.underlineHeight,
+      fontFamily: label.fontFamily,
+      cacheMode: label.cacheMode,
+      font: label.font ? label.font['_uuid'] : null,
+    };
+
+    const keys = Object.keys(current);
+    for (let key of keys) {
+      if (current[key] !== this._cachedProperties[key]) {
+        this._cachedProperties = current;
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  protected onPropertyChanged(): void {
+    if (CC_EDITOR && this.enableLabelCustomColors) {
+      this.restoreOriginalAssembler();
+      this.refreshGradient();
+    }
+  }
+
+  protected onDisable(): void {
+    this.restoreOriginalAssembler();
+  }
+
+  private adjustLabel(): void {
+    if (CC_EDITOR && !this.node.label) {
+      this.node.label = this.node.getComponent(cc.Label);
+    }
+    if (this.node.label) {
+      if (this.gradientDirection === 1) {
+        this.node.label.lineHeight = this.node.label.fontSize * 0.8;
+      }
+
+      if (!this._horizontalAlign) {
+        this._horizontalAlign = this.node.label.horizontalAlign;
+      }
+
+      if (!this._verticalAlign) {
+        this._verticalAlign = this.node.label.verticalAlign;
+      }
+    }
+  }
+
+  protected update(dt: number): void {
+    if (!CC_EDITOR) return;
+    if (this.checkLabelPropertiesChanged()) {
+      setTimeout(() => {
+        this.adjustLabel();
+        this.onRefreshEditor();
+      }, 100);
+    }
+  }
+
+  private onUpdateAssembler(): void {
+    if (this.enableLabelCustomColors && this.node.label) {
+      this.patchAssembler();
+    } else {
+      this.restoreOriginalAssembler();
+    }
+  }
+
+  private patchAssembler(): void {
+    const label = this.node.label;
+    if (!label || !label['_assembler'] || this._isPatched) return;
+
+    const assembler = label['_assembler'];
+
+    if (!this._isOriginalDataSaved) {
+      this._originalRenderData = FWLodash.cloneDeep(assembler);
+      this._isOriginalDataSaved = true;
+    }
+
+    const colorSegments = this.createColorSegments();
+    if (!colorSegments) return;
+
+    if (!this._originalUpdateRenderData) {
+      this._originalUpdateRenderData = assembler.updateRenderData;
+    }
+    if (!this._originalFillBuffers) {
+      this._originalFillBuffers = assembler.fillBuffers;
+    }
+
+    assembler.updateRenderData = () => {
+      if (this._originalUpdateRenderData) {
+        this._originalUpdateRenderData.call(assembler, label);
+      }
+      this.applyMultiColorGradient(assembler, colorSegments);
+    };
+
+    assembler.fillBuffers = (renderer: any, node: any) => {
+      this.fillGradientBuffers(renderer, node, assembler);
+    };
+    if (colorSegments.length > 2) {
+    }
+
+    this._isPatched = true;
+    assembler.updateRenderData();
+  }
+
+  private restoreOriginalAssembler(): void {
+    if (!this.node.label || !this._isOriginalDataSaved) return;
+
+    const label = this.node.label;
+    if (label['_assembler']) {
+      const assembler = label['_assembler'];
+
+      if (this._originalUpdateRenderData) {
+        assembler.updateRenderData = this._originalUpdateRenderData;
+      }
+      if (this._originalFillBuffers) {
+        assembler.fillBuffers = this._originalFillBuffers;
+      }
+
+      if (this._originalRenderData) {
+        label['_assembler'] = FWLodash.cloneDeep(this._originalRenderData);
+      }
+    }
+
+    this._isPatched = false;
+  }
+
+  private applyMultiColorGradient(
+    assembler: any,
+    colorSegments: FW.AssemblerLabelColorSegment[],
+  ): void {
+    const renderData = assembler._renderData;
+    const originalUintVData = renderData.uintVDatas[0];
+    const charsCount = originalUintVData.length / 20;
+    const segmentsCount = colorSegments.length - 1;
+    const useVertical = this.gradientDirection === 1;
+
+    const verticesPerChar = segmentsCount * 4;
+    const newVertexCount = charsCount * verticesPerChar;
+    const newUintVData = new Uint32Array(newVertexCount * 5);
+
+    let writeIndex = 0;
+
+    for (let c = 0; c < charsCount; c++) {
+      const base = c * 20;
+      const vertices = this.getCharacterVertices(originalUintVData, base);
+      const bounds = this.calculateBounds(vertices);
+
+      for (let s = 0; s < segmentsCount; s++) {
+        const segment = colorSegments[s];
+        const nextSegment = colorSegments[s + 1];
+
+        if (useVertical) {
+          this.createVerticalSegment(
+            newUintVData,
+            writeIndex,
+            vertices,
+            bounds,
+            segment,
+            nextSegment,
+          );
+        } else {
+          this.createHorizontalSegment(
+            newUintVData,
+            writeIndex,
+            vertices,
+            bounds,
+            segment,
+            nextSegment,
+          );
+        }
+        writeIndex += 4;
+      }
+    }
+
+    this.updateRenderData(renderData, newUintVData, charsCount, segmentsCount);
+  }
+
+  private getCharacterVertices(uintVData: Uint32Array, baseIndex: number): any[] {
+    const vertices = [];
+    for (let i = 0; i < 4; i++) {
+      const idx = baseIndex + i * 5;
+      vertices.push({
+        x: this.uintToFloat(uintVData[idx]),
+        y: this.uintToFloat(uintVData[idx + 1]),
+        u: this.uintToFloat(uintVData[idx + 2]),
+        v: this.uintToFloat(uintVData[idx + 3]),
+      });
+    }
+    return vertices;
+  }
+
+  private calculateBounds(vertices: any[]): any {
+    const xs = vertices.map((v) => v.x);
+    const ys = vertices.map((v) => v.y);
+    return {
+      minX: Math.min(...xs),
+      maxX: Math.max(...xs),
+      minY: Math.min(...ys),
+      maxY: Math.max(...ys),
+      width: Math.max(...xs) - Math.min(...xs),
+      height: Math.max(...ys) - Math.min(...ys),
+    };
+  }
+
+  private createHorizontalSegment(
+    newUintVData: Uint32Array,
+    writeIndex: number,
+    vertices: any[],
+    bounds: any,
+    segment: any,
+    nextSegment: any,
+  ): void {
+    const startX = bounds.minX + bounds.width * segment.position;
+    const endX = bounds.minX + bounds.width * nextSegment.position;
+    const startU = vertices[0].u + (vertices[1].u - vertices[0].u) * segment.position;
+    const endU = vertices[0].u + (vertices[1].u - vertices[0].u) * nextSegment.position;
+
+    this.setVertexData(
+      newUintVData,
+      writeIndex,
+      startX,
+      bounds.minY,
+      startU,
+      vertices[0].v,
+      segment.color._val,
+    );
+    this.setVertexData(
+      newUintVData,
+      writeIndex + 1,
+      endX,
+      bounds.minY,
+      endU,
+      vertices[1].v,
+      nextSegment.color._val,
+    );
+    this.setVertexData(
+      newUintVData,
+      writeIndex + 2,
+      startX,
+      bounds.maxY,
+      startU,
+      vertices[2].v,
+      segment.color._val,
+    );
+    this.setVertexData(
+      newUintVData,
+      writeIndex + 3,
+      endX,
+      bounds.maxY,
+      endU,
+      vertices[3].v,
+      nextSegment.color._val,
+    );
+  }
+
+  private createVerticalSegment(
+    newUintVData: Uint32Array,
+    writeIndex: number,
+    vertices: any[],
+    bounds: any,
+    segment: any,
+    nextSegment: any,
+  ): void {
+    const startY = bounds.minY + bounds.height * (1 - segment.position);
+    const endY = bounds.minY + bounds.height * (1 - nextSegment.position);
+
+    const startVL = vertices[0].v + (vertices[2].v - vertices[0].v) * (1 - segment.position);
+    const endVL = vertices[0].v + (vertices[2].v - vertices[0].v) * (1 - nextSegment.position);
+    const startVR = vertices[1].v + (vertices[3].v - vertices[1].v) * (1 - segment.position);
+    const endVR = vertices[1].v + (vertices[3].v - vertices[1].v) * (1 - nextSegment.position);
+
+    this.setVertexData(
+      newUintVData,
+      writeIndex,
+      bounds.minX,
+      startY,
+      vertices[0].u,
+      startVL,
+      segment.color._val,
+    );
+    this.setVertexData(
+      newUintVData,
+      writeIndex + 1,
+      bounds.maxX,
+      startY,
+      vertices[1].u,
+      startVR,
+      segment.color._val,
+    );
+    this.setVertexData(
+      newUintVData,
+      writeIndex + 2,
+      bounds.minX,
+      endY,
+      vertices[2].u,
+      endVL,
+      nextSegment.color._val,
+    );
+    this.setVertexData(
+      newUintVData,
+      writeIndex + 3,
+      bounds.maxX,
+      endY,
+      vertices[3].u,
+      endVR,
+      nextSegment.color._val,
+    );
+  }
+
+  private setVertexData(
+    data: Uint32Array,
+    index: number,
+    x: number,
+    y: number,
+    u: number,
+    v: number,
+    color: number,
+  ): void {
+    const base = index * 5;
+    data[base] = this.floatToUint(x);
+    data[base + 1] = this.floatToUint(y);
+    data[base + 2] = this.floatToUint(u);
+    data[base + 3] = this.floatToUint(v);
+    data[base + 4] = color;
+  }
+
+  private updateRenderData(
+    renderData: any,
+    newUintVData: Uint32Array,
+    charsCount: number,
+    segmentsCount: number,
+  ): void {
+    renderData.uintVDatas[0] = newUintVData;
+    renderData.iDatas[0] = this.createQuadMeshIndices(charsCount, segmentsCount);
+    renderData.vertexCount = newUintVData.length / 5;
+
+    const newVData = new Float32Array(renderData.vertexCount * 5);
+    for (let i = 0; i < newVData.length; i++) {
+      newVData[i] = this.uintToFloat(newUintVData[i]);
+    }
+    renderData.vDatas[0] = newVData;
+  }
+
+  private createQuadMeshIndices(charsCount: number, segmentsCount: number): Uint16Array {
+    const indicesPerChar = segmentsCount * 6;
+    const totalIndices = charsCount * indicesPerChar;
+    const indices = new Uint16Array(totalIndices);
+    let idx = 0;
+
+    for (let charIndex = 0; charIndex < charsCount; charIndex++) {
+      const vertexOffset = charIndex * segmentsCount * 4;
+
+      for (let segIndex = 0; segIndex < segmentsCount; segIndex++) {
+        const base = vertexOffset + segIndex * 4;
+        indices[idx++] = base;
+        indices[idx++] = base + 1;
+        indices[idx++] = base + 2;
+        indices[idx++] = base + 1;
+        indices[idx++] = base + 3;
+        indices[idx++] = base + 2;
+      }
+    }
+
+    return indices;
+  }
+
+  private getLabelBounds(uintVData: Uint32Array): any {
+    let minX = Number.MAX_VALUE,
+      maxX = -Number.MAX_VALUE;
+    let minY = Number.MAX_VALUE,
+      maxY = -Number.MAX_VALUE;
+
+    for (let i = 0; i < uintVData.length; i += 5) {
+      const x = this.uintToFloat(uintVData[i]);
+      const y = this.uintToFloat(uintVData[i + 1]);
+      minX = Math.min(minX, x);
+      maxX = Math.max(maxX, x);
+      minY = Math.min(minY, y);
+      maxY = Math.max(maxY, y);
+    }
+
+    return {
+      minX,
+      maxX,
+      minY,
+      maxY,
+      width: Math.max(maxX - minX, 1),
+      height: Math.max(maxY - minY, 1),
+    };
+  }
+
+  private fillGradientBuffers(renderer: any, node: any, assembler: any): void {
+    const renderData = assembler._renderData;
+    if (!renderData?.vDatas?.[0] || !renderData?.iDatas?.[0]) return;
+
+    const buffer = node._buffer;
+    const offsetInfo = buffer.request(renderData.vertexCount, renderData.iDatas[0].length);
+
+    const vertexOffset = offsetInfo.byteOffset >> 2;
+    buffer._vData.set(renderData.vDatas[0], vertexOffset);
+
+    const ibuf = buffer._iData;
+    const vertexId = offsetInfo.vertexOffset;
+
+    renderData.iDatas[0].forEach((index, i) => {
+      ibuf[offsetInfo.indiceOffset + i] = vertexId + index;
+    });
+  }
+
+  private createColorSegments(): FW.AssemblerLabelColorSegment[] | null {
+    if (!this._colors || this._colors.length < 2) return null;
+
+    const percentages = this.calculatePercentages();
+    const segments: FW.AssemblerLabelColorSegment[] = [];
+
+    for (let i = 0; i < this._colors.length; i++) {
+      segments.push({
+        color: this.cloneColor(this._colors[i]),
+        position: percentages[i],
+      });
+    }
+
+    return segments;
+  }
+
+  private calculatePercentages(): number[] {
+    if (this._percentages?.length === this._colors.length) {
+      const percentages = [...this._percentages];
+      percentages[0] = 0;
+      percentages[percentages.length - 1] = 1;
+
+      for (let i = 1; i < percentages.length - 1; i++) {
+        if (percentages[i] <= percentages[i - 1]) {
+          percentages[i] = percentages[i - 1] + 0.001;
+        }
+        if (percentages[i] >= percentages[i + 1]) {
+          percentages[i] = (percentages[i - 1] + percentages[i + 1]) / 2;
+        }
+      }
+      return percentages;
+    }
+
+    return Array.from({ length: this._colors.length }, (_, i) => i / (this._colors.length - 1));
+  }
+
+  private cloneColor(color: cc.Color): cc.Color {
+    return color.clone ? color.clone() : cc.color(color.r, color.g, color.b, color.a);
+  }
+
+  private interpolateColor(color1: cc.Color, color2: cc.Color, progress: number): cc.Color {
+    const r = Math.round(color1.r + (color2.r - color1.r) * progress);
+    const g = Math.round(color1.g + (color2.g - color1.g) * progress);
+    const b = Math.round(color1.b + (color2.b - color1.b) * progress);
+    const a = Math.round(color1.a + (color2.a - color1.a) * progress);
+    return cc.color(r, g, b, a);
+  }
+
+  private uintToFloat(uintValue: number): number {
+    const buffer = new ArrayBuffer(4);
+    const uintView = new Uint32Array(buffer);
+    const floatView = new Float32Array(buffer);
+    uintView[0] = uintValue;
+    return floatView[0];
+  }
+
+  private floatToUint(floatValue: number): number {
+    const buffer = new ArrayBuffer(4);
+    const floatView = new Float32Array(buffer);
+    const uintView = new Uint32Array(buffer);
+    floatView[0] = floatValue;
+    return uintView[0];
+  }
+}

package/render/FWRenderAssembler.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "040c0953-9ad0-4720-8e60-e3e15bd539d4",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/render.meta

@@ -0,0 +1,13 @@
+{
+  "ver": "1.1.3",
+  "uuid": "d49ee3cc-a25e-4c14-8a04-5f22d03b8164",
+  "importer": "folder",
+  "isBundle": false,
+  "bundleName": "",
+  "priority": 1,
+  "compressionType": {},
+  "optimizeHotUpdate": {},
+  "inlineSpriteFrames": {},
+  "isRemoteBundle": {},
+  "subMetas": {}
+}