自定义图集加载代码：

import { Global } from "../../../Global";
import { LoaderUtil } from "../../utils/LoaderUtil";
import { LoaderDef } from "../LoaderDef";
import { AniAtlasResource } from "./AniAtlasResource";
import { IAtlasData } from "./IAtlasData";

export class AniAtlasLoader implements Laya.IResourceLoader {

    load(task: Laya.ILoadTask) {
        let info = LoaderUtil.getInfo(task.url);
        if (null != info && null != info.data) {
            info.clearTime = NaN;
            return this.onLoad(task, info.data);
        }
        return task.loader.fetch(task.url, "json", task.progress.createCallback(0.2), task.options).then((data: IAtlasData) => {
            LoaderUtil.setData(task.url, data);
            return this.onLoad(task, data);
        });
    }

    private analysis(task: Laya.ILoadTask, data: IAtlasData): void {
        if (data.hasAnalysis) return;
        data.hasAnalysis = true;
        let baseUrl = task.options.baseUrl || "";
        let folderPath: string = "";
        let i = task.url.lastIndexOf("/");
        if (i != -1) {
            folderPath = task.url.substring(0, i + 1);
        }
        let directory: string = task.url.substring(0, task.url.lastIndexOf(".")) + "/";
        let aniImgs: Array<{ url: string, frame: string }>
        if (Laya.LayaEnv.isConch && data.common && data.common.isSplit) {
            delete data.common.isSplit;
            data.anis = null;
        }
        if (data.common && data.common.isSplit) {
            for (let aniName in data.anis) {
                aniImgs = data.anis[aniName];
                for (let j: number = 0; j < aniImgs.length; ++j) {
                    aniImgs[j].url = folderPath + aniImgs[j].url;
                    if (Laya.LayaEnv.isConch) {
                        aniImgs[j].url = aniImgs[j].url.replace(".webp", ".png");
                    }
                }
            }
        } else if (null == data.anis) {
            data.anis = Object.create(null);
            let aniName: string, url: string;
            for (let name in data.frames) {
                i = name.lastIndexOf("_");
                url = baseUrl + directory + name;
                aniName = i == -1 ? "0" : name.substring(0, i);
                if (null == data.anis[aniName]) {
                    data.anis[aniName] = [{ url: url, frame: name }];
                } else {
                    data.anis[aniName].push({ url: url, frame: name });
                }
            }
            for (let aniName in data.anis) {
                data.anis[aniName].sort(AniAtlasLoader.sortUrl);
            }
        } else {
            for (let aniName in data.anis) {
                aniImgs = data.anis[aniName];
                for (let j: number = 0; j < aniImgs.length; ++j) {
                    aniImgs[j].url = baseUrl + directory + aniImgs[j].frame;
                }
            }
        }
    }

    private analysisSplit(task: Laya.ILoadTask, data: IAtlasData): void {
        if (data.hasSplit) return;
        if (!Global.engine.isFrameExtraction) return;
        for (let i: number = 0; i < LoaderDef.IgnoralFrameExtractions.length; ++i) {
            if (task.url.indexOf(LoaderDef.IgnoralFrameExtractions[i]) != -1) {
                return;
            }
        }
        data.hasSplit = true;
        if (Laya.LayaEnv.isConch) return;
        if (data.common && data.common.isSplit) {
            let aniImgs: Array<{ url: string, frame: string }>, newImgs: Array<{ url: string, frame: string }>;
            newImgs = [];
            for (let aniName in data.anis) {
                aniImgs = data.anis[aniName];
                for (let j: number = 0; j < aniImgs.length; ++j) {
                    if (j % 2 == 0) {
                        newImgs.push(aniImgs[j]);
                    }
                }
                data.anis[aniName] = newImgs;
            }
        }
        // 抽帧时帧率倍数处理
        if (data.common.frameRate) {
            data.common.frameRate = Math.ceil(data.common.frameRate * Global.engine.frameExtractionRate);
        }
    }

    private onLoad(task: Laya.ILoadTask, data: IAtlasData): Promise<AniAtlasResource> {
        if (null == data) return Promise.resolve(null);
        this.analysis(task, data);
        this.analysisSplit(task, data);
        let baseUrl = task.options.baseUrl || "";
        let folderPath: string = "";
        let i = task.url.lastIndexOf("/");
        if (i != -1) {
            folderPath = task.url.substring(0, i + 1);
        }

        let betterAni: boolean = Global.engine.betterAni && task.url.indexOf(LoaderDef.NoBetterAni) == -1;

        let toloadPics: Array<Promise<Laya.Texture>> = [];
        if (!Laya.LayaEnv.isConch && data.common && data.common.isSplit == 1) {
            let aniImgs: Array<{ url: string, frame: string }>;
            for (let aniName in data.anis) {
                aniImgs = data.anis[aniName];
                for (let j: number = 0; j < aniImgs.length; ++j) {
                    // 优化加载时，先只加载第一张图，后续图片依次加载
                    if (betterAni && j > 0) continue;
                    toloadPics.push(task.loader.load(aniImgs[j].url, null, task.progress.createCallback()));
                }
            }

        } else if (data.meta && data.meta.image) {
            //如果图集带了版本号，需要将图集中包含的图片也需要追加版本号，以此解决浏览器缓存的问题
            let query: string = "";
            i = task.url.lastIndexOf("?");
            if (i != -1)
                query = task.url.substring(i);

            //带图片信息的类型
            let pics: Array<string> = data.meta.image.split(",");
            for (let pic of pics) {
                if (Laya.LayaEnv.isConch) pic = pic.replace(".png", ".ktx");
                toloadPics.push(task.loader.load(folderPath + pic + query, null, task.progress.createCallback()));
            }
        } else {  //不带图片信息
            toloadPics.push(task.loader.load(Laya.Utils.replaceFileExtension(task.url, "png"), null, task.progress.createCallback()));
        }

        return Promise.all(toloadPics).then(pics => {
            let frames: any = data.frames;
            let directory: string = task.url.substring(0, task.url.lastIndexOf(".")) + "/";
            let subTextures: Array<Laya.Texture> = [];
            let frameTextures: { [url: string]: Laya.Texture } = {};

            let scaleRate: number = 1;
            if (data.meta && data.meta.scale && data.meta.scale != 1)
                scaleRate = parseFloat(data.meta.scale);

            for (let tPic of pics) {
                if (tPic) {
                    tPic._addReference();
                    tPic.scaleRate = scaleRate;
                }
            }

            let waitLoads: { [aniName: string]: Array<number> } = null;
            if (!Laya.LayaEnv.isConch && data.common && data.common.isSplit == 1) {
                let aniImgs: Array<{ url: string, frame: string }>, aniUrl: string, idx: number = 0;
                if (betterAni) waitLoads = Object.create(null);
                for (let aniName in data.anis) {
                    aniImgs = data.anis[aniName];
                    if (betterAni) waitLoads[aniName] = [];
                    for (let j: number = 0; j < aniImgs.length; ++j) {
                        // 优化加载时，先只加载第一张图，后续图片依次加载
                        if (betterAni && j > 0) {
                            waitLoads[aniName].push(j);
                        }
                        aniUrl = aniImgs[j].url;
                        frameTextures[aniUrl] = pics[idx++];
                    }
                    if (betterAni) waitLoads[aniName].sort(AniAtlasLoader.sortWaitIdx);
                }
            } else {
                let url: string, tt: Laya.Texture;
                for (let name in frames) {
                    let obj = frames[name];
                    let tPic = pics[obj.frame.idx ? obj.frame.idx : 0];
                    if (!tPic)
                        continue;

                    url = baseUrl + directory + name;
                    tt = Laya.Texture.create(tPic, obj.frame.x, obj.frame.y, obj.frame.w, obj.frame.h, obj.spriteSourceSize.x, obj.spriteSourceSize.y, null == obj.sourceSize.x ? obj.sourceSize.w : obj.sourceSize.x, null == obj.sourceSize.y ? obj.sourceSize.h : obj.sourceSize.y);
                    tt.lock = true;
                    // @ts-ignore
                    tt._sizeGrid = obj.sizeGrid;
                    // @ts-ignore
                    tt._stateNum = obj.stateNum;
                    task.loader.cacheRes(url, tt);
                    tt.url = url;
                    subTextures.push(tt);
                    frameTextures[url] = tt;
                }
            }
            let resource = AniAtlasResource.NEW(data, directory, pics, subTextures, frameTextures);
            resource.taskUrl = task.url;
            resource.startWaitLoad(waitLoads);
            return resource;
        });
    }

    private static sortWaitIdx(a: number, b: number): number {
        let num: number = (a % 2 == 1 ? 0 : 1) - (b % 2 == 1 ? 0 : 1);
        if (num == 0) num = a - b;
        return num;
    }

    public static sortUrl(n1: { url: string, frame: string }, n2: { url: string, frame: string }): number {
        let n1Idx = n1.frame.lastIndexOf('_');
        let n1Num = n1Idx > 0 ? parseInt(n1.frame.substring(n1Idx + 1)) : parseInt(n1.frame);
        let n2Idx = n2.frame.lastIndexOf('_');
        let n2Num = n2Idx > 0 ? parseInt(n2.frame.substring(n2Idx + 1)) : parseInt(n2.frame);
        return n1Num - n2Num;
    }
}

import { Global } from "../../../Global";
import { PoolListFrame } from "../../../objectPool/PoolListFrame";
import { ObjectUtil } from "../../../utils/ObjectUtil";
import { StrUtil } from "../../../utils/StrUtil";
import { LoaderUtil } from "../../utils/LoaderUtil";
import { IAtlasData } from "./IAtlasData";

export class AniAtlasResource extends Laya.Resource {
    private static _pool: PoolListFrame<AniAtlasResource> = null;

    public static NEW(data: IAtlasData, dir: string, textures: Array<Laya.Texture>, frames: Array<Laya.Texture>, frameDic: { [name: string]: Laya.Texture }): AniAtlasResource {
        if(null == AniAtlasResource._pool) AniAtlasResource._pool = new PoolListFrame<AniAtlasResource>(AniAtlasResource);
        return AniAtlasResource._pool.alloc().setData(data, dir, textures, frames, frameDic);
    }

    public static recycle(obj: AniAtlasResource): void {
        if(null == AniAtlasResource._pool) return;
        AniAtlasResource._pool.recycle(obj);
    }

    public recycled: boolean;
    public uid: string;
    private _dir: string;
    private _textures: Array<Laya.Texture>;
    private _frames: Array<Laya.Texture>;
    private _data: IAtlasData;
    private _frameDic: { [name: string]: Laya.Texture };

    private _waitLoads: { [aniName: string]: Array<number> };
    private _waitLoading: string;
    public taskUrl: string;

    /**
     * 实例化体格大图合集资源
     * @param dir
     * @param textures
     * @param frames
     */
    constructor() {
        super();
        this.lock = true;
        this.uid = ObjectUtil.getUid(this);
    }

    public setData(data: IAtlasData, dir: string, textures: Array<Laya.Texture>, frames: Array<Laya.Texture>, frameDic: { [name: string]: Laya.Texture }): AniAtlasResource {
        this._dir = dir;
        this._textures = textures;
        this._frames = frames;
        this._data = data;
        this._frameDic = frameDic;

        this.lock = true;
        this._referenceCount = 0;
        Laya.Resource._idResourcesMap[this._id] = this;

        return this;
    }

    onRecycle(): void {
        this._destroyed = false;
        this.lock = true;
    }

    public destroy(): void {
        super.destroy();
        this.url = null;
    }

    /**
     * @internal
     */
    protected _disposeResource(): void {
        LoaderUtil.setClear(this.taskUrl, this._data);
        if (StrUtil.isValidStr(this._waitLoading)) {
            Laya.loader.cancelLoadByUrl(this._waitLoading);
            this._waitLoading = null;
        }
        this._waitLoads = null;
        this._dir = null;
        if (this._textures) {
            for (let tex of this._textures) {
                if (tex && null == Global.loader.getLoaderItem(tex.url)) tex.destroy();
            }
            this._textures.length = 0;
            this._textures = null;
        }

        if (this._frames) {
            for (let tex of this._frames) if (tex && null == Global.loader.getLoaderItem(tex.url)) tex.destroy();
            this._frames.length = 0;
            this._frames = null;
        }

        if (null != this._frameDic) {
            for (let key in this._frameDic) {
                delete this._frameDic[key];
            }
            this._frameDic = null;
        }
        this._data = null;
        this.taskUrl = null;
        AniAtlasResource.recycle(this);
    }

    public get dir(): string {
        return this._dir;
    }

    public get textures(): Array<Laya.Texture> {
        return this._textures;
    }

    public get frames(): Array<Laya.Texture> {
        return this._frames;
    }

    public get frameDic(): { [name: string]: Laya.Texture } {
        return this._frameDic;
    }

    public get data(): IAtlasData {
        return this._data;
    }

    public startWaitLoad(waitLoads: { [aniName: string]: Array<number> }): void {
        this._waitLoads = waitLoads;
        this.loadNextWait();
    }

    private loadNextWait(): void {
        if (null == this._waitLoads) return;
        let idxs: Array<number>, idx: number;
        for (let aniName in this._waitLoads) {
            idxs = this._waitLoads[aniName];
            if (idxs.length == 0) {
                delete this._waitLoads[aniName];
                continue;
            }
            idx = idxs.shift();

            let url: string = this._data.anis[aniName][idx].url;
            this._waitLoading = url;
            Laya.loader.load(url).then((pic: Laya.Texture) => {
                this._waitLoading = null;
                if (this.destroyed || this.recycled) {
                    if (pic) {
                        if (pic.referenceCount > 0) {
                            pic._removeReference();
                        } else {
                            pic.destroy();
                        }
                    }
                    return;
                }
                this._textures.push(pic);
                this.frameDic[url] = pic;
                this.loadNextWait();
            });
            return;
        }
        this._waitLoads = null;
    }
}

图集信息 .atlas文件内容：

{
  "common": {
    "blendMode": 0,
    "frameRate": 15,
    "ofsX": -400,
    "ofsY": -500
  },
  "meta": {
    "prefix": "res/ani/fx/general/xuanzhong_xiaoguai_2/",
    "image": "xuanzhong_xiaoguai_2.png"
  },
  "frames": {
    "0": {
      "sourceSize": {
        "w": 800,
        "h": 166
      },
      "frame": {
        "h": 166,
        "y": 708,
        "w": 194,
        "x": 2
      },
      "spriteSourceSize": {
        "y": 381,
        "x": 303
      }
    },
    "1": {
      "sourceSize": {
        "w": 800,
        "h": 166
      },
      "frame": {
        "h": 166,
        "y": 674,
        "w": 194,
        "x": 198
      },
      "spriteSourceSize": {
        "y": 381,
        "x": 303
      }
    },
    "2": {
      "sourceSize": {
        "w": 800,
        "h": 166
      },
      "frame": {
        "h": 166,
        "y": 540,
        "w": 194,
        "x": 2
      },
      "spriteSourceSize": {
        "y": 381,
        "x": 303
      }
    },
    "3": {
      "sourceSize": {
        "w": 800,
        "h": 166
      },
      "frame": {
        "h": 166,
        "y": 506,
        "w": 194,
        "x": 198
      },
      "spriteSourceSize": {
        "y": 381,
        "x": 303
      }
    },
    "4": {
      "sourceSize": {
        "w": 800,
        "h": 166
      },
      "frame": {
        "h": 166,
        "y": 372,
        "w": 194,
        "x": 2
      },
      "spriteSourceSize": {
        "y": 381,
        "x": 303
      }
    },
    "5": {
      "sourceSize": {
        "w": 800,
        "h": 200
      },
      "frame": {
        "h": 200,
        "y": 2,
        "w": 232,
        "x": 2
      },
      "spriteSourceSize": {
        "y": 364,
        "x": 284
      }
    },
    "6": {
      "sourceSize": {
        "w": 800,
        "h": 166
      },
      "frame": {
        "h": 166,
        "y": 338,
        "w": 194,
        "x": 198
      },
      "spriteSourceSize": {
        "y": 381,
        "x": 303
      }
    },
    "7": {
      "sourceSize": {
        "w": 800,
        "h": 166
      },
      "frame": {
        "h": 166,
        "y": 204,
        "w": 194,
        "x": 2
      },
      "spriteSourceSize": {
        "y": 381,
        "x": 303
      }
    },
    "8": {
      "sourceSize": {
        "w": 800,
        "h": 166
      },
      "frame": {
        "h": 166,
        "y": 170,
        "w": 194,
        "x": 236
      },
      "spriteSourceSize": {
        "y": 381,
        "x": 303
      }
    },
    "9": {
      "sourceSize": {
        "w": 800,
        "h": 166
      },
      "frame": {
        "h": 166,
        "y": 2,
        "w": 194,
        "x": 236
      },
      "spriteSourceSize": {
        "y": 381,
        "x": 303
      }
    }
  },
  "anis": {
    "0": [
      {
        "url": "xuanzhong_xiaoguai_2_0.webp",
        "frame": "0"
      },
      {
        "url": "xuanzhong_xiaoguai_2_1.webp",
        "frame": "1"
      },
      {
        "url": "xuanzhong_xiaoguai_2_2.webp",
        "frame": "2"
      },
      {
        "url": "xuanzhong_xiaoguai_2_3.webp",
        "frame": "3"
      },
      {
        "url": "xuanzhong_xiaoguai_2_4.webp",
        "frame": "4"
      },
      {
        "url": "xuanzhong_xiaoguai_2_5.webp",
        "frame": "5"
      },
      {
        "url": "xuanzhong_xiaoguai_2_6.webp",
        "frame": "6"
      },
      {
        "url": "xuanzhong_xiaoguai_2_7.webp",
        "frame": "7"
      },
      {
        "url": "xuanzhong_xiaoguai_2_8.webp",
        "frame": "8"
      },
      {
        "url": "xuanzhong_xiaoguai_2_9.webp",
        "frame": "9"
      }
    ]
  }
}

图集图片：

测试，创建一个Laya.Sprite，对其添加变色(Laya.ColorEffect2D)后处理，只设置hue=-59，如果创建的Sprite使用AniAtlasResource中单个frame创建的Texture，则会看不见图片，清理掉变色的后处理就可以正常显示，
如果创建的Sprite使用 AniAtlasResource中的图集图片，也会正常显示