lyb-pixi-js 1.12.40 → 1.12.41

package/Utils/LibPixiEvent.d.ts

@@ -0,0 +1,19 @@
+import type { Container, DisplayObjectEvents, FederatedPointerEvent } from "pixi.js";
+export interface LibPixiEventParams {
+    /** 是否只执行一次 */
+    once?: boolean;
+    /** 是否启用防抖 */
+    debounce?: boolean;
+    /** 防抖时长 */
+    debounceTime?: number;
+    /** 是否阻止拖动点击 */
+    preventDragClick?: boolean;
+}
+/** @description 事件注册
+ * @param v 事件容器
+ * @param eventName 事件名称
+ * @param callback 回调函数
+ * @returns 停止监听
+ * @link 使用方法：https://www.npmjs.com/package/lyb-pixi-js#LibPixiEvent-事件注册
+ */
+export declare const libPixiEvent: (v: Container, eventName: keyof DisplayObjectEvents, callback: (event: FederatedPointerEvent) => void, params?: LibPixiEventParams) => () => void;

package/Utils/LibPixiEvent.js

@@ -0,0 +1,68 @@
+const debounceImmediate = (func, wait) => {
+    let timer = null;
+    let invoked = false;
+    return (...args) => {
+        if (!invoked) {
+            func(...args);
+            invoked = true;
+        }
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(() => {
+            invoked = false;
+        }, wait);
+    };
+};
+/** @description 事件注册
+ * @param v 事件容器
+ * @param eventName 事件名称
+ * @param callback 回调函数
+ * @returns 停止监听
+ * @link 使用方法：https://www.npmjs.com/package/lyb-pixi-js#LibPixiEvent-事件注册
+ */
+export const libPixiEvent = (v, eventName, callback, params = {}) => {
+    const { once = false, debounce = false, debounceTime = 1000, preventDragClick = false, } = params;
+    v.cursor = "pointer";
+    v.eventMode = "static";
+    let lastX = 0;
+    let lastY = 0;
+    let isDragging = false;
+    if (preventDragClick) {
+        v.on("pointerdown", (e) => {
+            isDragging = false;
+            lastX = e.globalX;
+            lastY = e.globalY;
+            const threshold = 10; // 阈值像素
+            const moveHandler = (ev) => {
+                const dx = ev.globalX - lastX;
+                const dy = ev.globalY - lastY;
+                if (dx * dx + dy * dy > threshold * threshold) {
+                    isDragging = true;
+                }
+            };
+            const upHandler = () => {
+                v.off("pointermove", moveHandler);
+                v.off("pointerup", upHandler);
+            };
+            v.on("pointermove", moveHandler);
+            v.on("pointerup", upHandler);
+        });
+    }
+    const fn = (e) => {
+        if (isDragging && ["pointertap", "pointerup"].includes(eventName))
+            return;
+        if (e.button === 2)
+            return;
+        callback(e);
+    };
+    const handler = debounce ? debounceImmediate(fn, debounceTime) : fn;
+    if (once) {
+        v.once(eventName, handler);
+    }
+    else {
+        v.on(eventName, handler);
+    }
+    return () => {
+        v.off(eventName, handler);
+    };
+};

package/Utils/LibPixiFilter.d.ts

@@ -0,0 +1,9 @@
+/** @description 设置滤镜 */
+import { ColorMatrixFilter, BlurFilter } from "pixi.js";
+export type LibPixiSetFilterFilterName = "brightness" | "blur" | "desaturate" | "contrast" | "saturate";
+/** @description 滤镜
+ * @param filterName 滤镜名称
+ * @param v 滤镜值
+ * @link 使用方法：https://www.npmjs.com/package/lyb-pixi-js#LibPixiFilter-滤镜
+ */
+export declare const libPixiFilter: (filterName: LibPixiSetFilterFilterName, v?: number) => ColorMatrixFilter | BlurFilter;

package/Utils/LibPixiFilter.js

@@ -0,0 +1,34 @@
+/** @description 设置滤镜 */
+import { ColorMatrixFilter, BlurFilter } from "pixi.js";
+/** @description 滤镜
+ * @param filterName 滤镜名称
+ * @param v 滤镜值
+ * @link 使用方法：https://www.npmjs.com/package/lyb-pixi-js#LibPixiFilter-滤镜
+ */
+export const libPixiFilter = (filterName, v) => {
+    let filter;
+    if (filterName === "brightness") {
+        filter = new ColorMatrixFilter();
+        filter.brightness(v, false); // 设置亮度
+    }
+    else if (filterName === "blur") {
+        filter = new BlurFilter();
+    }
+    else if (filterName === "desaturate") {
+        filter = new ColorMatrixFilter();
+        filter.desaturate();
+    }
+    else if (filterName === "contrast") {
+        filter = new ColorMatrixFilter();
+        filter.contrast(v, false);
+    }
+    else if (filterName === "saturate") {
+        filter = new ColorMatrixFilter();
+        filter.saturate(v, false);
+    }
+    else {
+        throw new Error("未知滤镜名称");
+    }
+    filter.resolution = window.devicePixelRatio || 1;
+    return filter;
+};

package/Utils/LibPixiGlobalUpdater.d.ts

@@ -0,0 +1,15 @@
+import type { Container } from "pixi.js";
+/** @description 事件总线更新实例汇总 */
+export declare class LibPixiGlobalUpdater<Instances> {
+    /** 实例列表 */
+    private instances;
+    /** @description 存储实例
+     * @param key 实例key
+     * @param instance 实例
+     */
+    setInstance(key: Instances, instance: Container): void;
+    /** @description 获取实例
+     * @param key 实例key
+     */
+    getInstance<T>(key: Instances): T;
+}

package/Utils/LibPixiGlobalUpdater.js

@@ -0,0 +1,21 @@
+/** @description 事件总线更新实例汇总 */
+export class LibPixiGlobalUpdater {
+    constructor() {
+        /** 实例列表 */
+        this.instances = new Map();
+    }
+    /** @description 存储实例
+     * @param key 实例key
+     * @param instance 实例
+     */
+    setInstance(key, instance) {
+        this.instances.has(key) && this.instances.delete(key);
+        this.instances.set(key, instance);
+    }
+    /** @description 获取实例
+     * @param key 实例key
+     */
+    getInstance(key) {
+        return this.instances.get(key);
+    }
+}

package/Utils/LibPixiGridLayout.d.ts

@@ -0,0 +1,10 @@
+import { Container } from "pixi.js";
+/**
+ * @description 将元素按照指定的列数和间隔排列成网格布局。
+ * @param items 要排列的元素数组
+ * @param gap 每个元素之间的间隔
+ * @param cols 网格的列数，默认为元素数量
+ * @link 使用方法：https://www.npmjs.com/package/lyb-pixi-js#LibPixiGridLayout-网格布局
+ * @param direction 排列方向: "row" 行优先(默认) | "col" 列优先
+ */
+export declare const LibPixiGridLayout: (items: Container[], gap: number, cols?: number, direction?: "row" | "col") => void;

package/Utils/LibPixiGridLayout.js

@@ -0,0 +1,27 @@
+/**
+ * @description 将元素按照指定的列数和间隔排列成网格布局。
+ * @param items 要排列的元素数组
+ * @param gap 每个元素之间的间隔
+ * @param cols 网格的列数，默认为元素数量
+ * @link 使用方法：https://www.npmjs.com/package/lyb-pixi-js#LibPixiGridLayout-网格布局
+ * @param direction 排列方向: "row" 行优先(默认) | "col" 列优先
+ */
+export const LibPixiGridLayout = (items, gap, cols = items.length, direction = "row") => {
+    const rows = Math.ceil(items.length / cols); // 动态计算行数
+    items.forEach((item, index) => {
+        const itemWidth = item.width || 0;
+        const itemHeight = item.height || 0;
+        let colIndex = 0;
+        let rowIndex = 0;
+        if (direction === "row") {
+            colIndex = index % cols;
+            rowIndex = Math.floor(index / cols);
+        }
+        else {
+            colIndex = Math.floor(index / rows);
+            rowIndex = index % rows;
+        }
+        item.x = colIndex * (itemWidth + gap);
+        item.y = rowIndex * (itemHeight + gap);
+    });
+};

package/Utils/LibPixiHVCenter.d.ts

@@ -0,0 +1,7 @@
+import { Container } from "pixi.js";
+/** @description 列表居中
+ * @param parent 父容器
+ * @param items 子元素数组
+ * @param direction 方向数组，"x"表示水平，"y"表示垂直
+ */
+export declare const libPixiHVCenter: (parent: Container, items: Container[], direction: ("x" | "y")[]) => void;

package/Utils/LibPixiHVCenter.js

@@ -0,0 +1,14 @@
+/** @description 列表居中
+ * @param parent 父容器
+ * @param items 子元素数组
+ * @param direction 方向数组，"x"表示水平，"y"表示垂直
+ */
+export const libPixiHVCenter = (parent, items, direction) => {
+    items.forEach((item) => {
+        direction.forEach((d) => {
+            item[d] =
+                parent[d === "x" ? "width" : "height"] / 2 -
+                    item[d === "x" ? "width" : "height"] / 2;
+        });
+    });
+};

package/Utils/LibPixiHVGap.d.ts

@@ -0,0 +1,8 @@
+import { Container } from "pixi.js";
+/**
+ * @description 按照指定方向（水平或垂直）排列元素，支持固定间隔或自定义每个间隔。
+ * @param items 要排列的元素数组。
+ * @param gap 元素之间的间隔，可以是固定间隔或自定义的间隔数组。
+ * @param direction 排列方向，"x"表示水平，"y"表示垂直，默认为水平。
+ */
+export declare const libPixiHVGap: (items: Container[], gap: number | number[], direction?: "x" | "y") => void;

package/Utils/LibPixiHVGap.js

@@ -0,0 +1,26 @@
+/**
+ * @description 按照指定方向（水平或垂直）排列元素，支持固定间隔或自定义每个间隔。
+ * @param items 要排列的元素数组。
+ * @param gap 元素之间的间隔，可以是固定间隔或自定义的间隔数组。
+ * @param direction 排列方向，"x"表示水平，"y"表示垂直，默认为水平。
+ */
+export const libPixiHVGap = (items, gap, direction = "x") => {
+    if (Array.isArray(gap)) {
+        if (gap.length !== items.length - 1) {
+            console.error(new Error("间隔的数组长度只能等于元素数组长度-1"));
+            return;
+        }
+    }
+    let lastPosition = 0;
+    items.forEach((item, index) => {
+        const position = index === 0 ? 0 : lastPosition + (Array.isArray(gap) ? gap[index - 1] : gap);
+        if (direction === "x") {
+            item.x = position;
+            lastPosition = item.x + item.width;
+        }
+        else {
+            item.y = position;
+            lastPosition = item.y + item.height;
+        }
+    });
+};

package/Utils/LibPixiIntervalTrigger.d.ts

@@ -0,0 +1,7 @@
+/** @description 间隔触发
+ * @param callback 回调函数
+ * @param interval 间隔毫秒，或随机范围
+ * @param immediately 是否立即执行一次
+ * @link 使用方法：https://www.npmjs.com/package/lyb-pixi-js#LibPixiIntervalTrigger-间隔触发
+ */
+export declare const libPixiIntervalTrigger: (callback: () => void, interval: number | [number, number], immediately?: boolean) => () => void;

package/Utils/LibPixiIntervalTrigger.js

@@ -0,0 +1,35 @@
+import { Ticker } from "pixi.js"; //@ts-ignore
+import { libJsRandom } from "lyb-js/Random/LibJsRandom.js";
+/** @description 间隔触发
+ * @param callback 回调函数
+ * @param interval 间隔毫秒，或随机范围
+ * @param immediately 是否立即执行一次
+ * @link 使用方法：https://www.npmjs.com/package/lyb-pixi-js#LibPixiIntervalTrigger-间隔触发
+ */
+export const libPixiIntervalTrigger = (callback, interval, immediately = true) => {
+    let elapsedTime = 0;
+    // 创建一个新的 Ticker 实例
+    const ticker = new Ticker();
+    // 创建回调函数
+    const tickerCallback = () => {
+        elapsedTime += ticker.elapsedMS;
+        let intervalNum = 0;
+        if (Array.isArray(interval)) {
+            intervalNum = libJsRandom(interval[0], interval[1], 2);
+        }
+        else {
+            intervalNum = interval;
+        }
+        if (elapsedTime >= intervalNum) {
+            callback();
+            elapsedTime = 0;
+        }
+    };
+    immediately && callback();
+    ticker.add(tickerCallback);
+    ticker.start();
+    return () => {
+        ticker.remove(tickerCallback);
+        ticker.stop();
+    };
+};

package/Utils/LibPixiOutsideClick.d.ts

@@ -0,0 +1,8 @@
+import type { Container } from "pixi.js";
+/** @description 点击容器外或入口按钮时隐藏
+ * @param container 容器
+ * @param btn 按钮
+ * @param onClose 关闭回调
+ * @link 使用方法：https://www.npmjs.com/package/lyb-pixi-js#LibPixiOutsideClick-失焦隐藏
+ */
+export declare const libPixiOutsideClick: (container: Container, btn: Container, onClose: () => void) => () => void;

package/Utils/LibPixiOutsideClick.js

@@ -0,0 +1,22 @@
+/** @description 点击容器外或入口按钮时隐藏
+ * @param container 容器
+ * @param btn 按钮
+ * @param onClose 关闭回调
+ * @link 使用方法：https://www.npmjs.com/package/lyb-pixi-js#LibPixiOutsideClick-失焦隐藏
+ */
+export const libPixiOutsideClick = (container, btn, onClose) => {
+    const outsideClick = (e) => {
+        const btnInside = btn.getBounds().contains(e.clientX, e.clientY);
+        const containerInside = container
+            .getBounds()
+            .contains(e.clientX, e.clientY);
+        if (!btnInside && !containerInside && container.visible) {
+            onClose();
+            window.removeEventListener("pointerdown", outsideClick);
+        }
+    };
+    window.addEventListener("pointerdown", outsideClick);
+    return () => {
+        window.removeEventListener("pointerdown", outsideClick);
+    };
+};

package/Utils/LibPixiOverflowHidden.d.ts

@@ -0,0 +1,6 @@
+import { Graphics, type Container } from "pixi.js";
+/** @description 为容器创建并应用一个矩形遮罩，用于隐藏溢出的内容，函数会返回遮罩，可控制是否显示遮罩
+ * @param container 需要设置遮罩裁剪的容器
+ * @link 使用方法：https://www.npmjs.com/package/lyb-pixi-js#LibPixiOverflowHidden-溢出裁剪
+ */
+export declare const libPixiOverflowHidden: (container: Container) => Graphics;

package/Utils/LibPixiOverflowHidden.js

@@ -0,0 +1,14 @@
+import { Graphics } from "pixi.js";
+/** @description 为容器创建并应用一个矩形遮罩，用于隐藏溢出的内容，函数会返回遮罩，可控制是否显示遮罩
+ * @param container 需要设置遮罩裁剪的容器
+ * @link 使用方法：https://www.npmjs.com/package/lyb-pixi-js#LibPixiOverflowHidden-溢出裁剪
+ */
+export const libPixiOverflowHidden = (container) => {
+    const mask = new Graphics();
+    mask.beginFill(0xffffff);
+    mask.drawRect(0, 0, container.width, container.height);
+    mask.endFill();
+    container.addChild(mask);
+    container.mask = mask;
+    return mask;
+};

package/Utils/LibPixiPolygonDrawTool.d.ts

@@ -0,0 +1,44 @@
+import { type Application } from "pixi.js";
+export interface LibPixiPolygonDrawToolParams {
+    /** 输出的数组内容格式 */
+    outFormat?: "object" | "number";
+    /** 圆点半径 */
+    dotRadius?: number;
+    /** 圆点颜色 */
+    dotColor?: string | number;
+    /** 多边形颜色 */
+    polygonColor?: string | number;
+    /** 多边形透明度 */
+    polygonAlpha?: number;
+}
+/** @description 多边形绘制工具，绘制时浏览器窗口需要全屏显示，空格键控制开始和结束，开始后鼠标进行点击绘制，退格删除点，空格结束绘制，绘制结果在控制台打印，不满意可再次按空格清空并重新绘制
+ * @link 使用方法：https://www.npmjs.com/package/lyb-pixi-js#LibPixiPolygonDrawTool-多边形绘制
+ */
+export declare class LibPixiPolygonDrawTool {
+    /** App */
+    private _app;
+    /** 多边形 */
+    private _polygon;
+    /** 是否正在绘制 */
+    private _drawing;
+    /** 储点的数组 */
+    private _points;
+    /** 起始点 */
+    private _startPoint;
+    /** 实际绘制的点 */
+    private _realPoints;
+    /** 点元素 */
+    private _pointElements;
+    /** 参数 */
+    private _params;
+    constructor(app: Application, params?: LibPixiPolygonDrawToolParams);
+    private _setupListeners;
+    /** @description 控制绘制开始和结束 */
+    private toggleDrawing;
+    /** @description 添加点坐标 */
+    private _addPoint;
+    /** @description 绘制多边形 */
+    private _drawPolygon;
+    /** @description 绘制一个点 */
+    private _drawDot;
+}

package/Utils/LibPixiPolygonDrawTool.js

@@ -0,0 +1,114 @@
+import { Graphics, } from "pixi.js";
+/** @description 多边形绘制工具，绘制时浏览器窗口需要全屏显示，空格键控制开始和结束，开始后鼠标进行点击绘制，退格删除点，空格结束绘制，绘制结果在控制台打印，不满意可再次按空格清空并重新绘制
+ * @link 使用方法：https://www.npmjs.com/package/lyb-pixi-js#LibPixiPolygonDrawTool-多边形绘制
+ */
+export class LibPixiPolygonDrawTool {
+    constructor(app, params = {}) {
+        /** 是否正在绘制 */
+        this._drawing = false;
+        /** 储点的数组 */
+        this._points = [];
+        /** 起始点 */
+        this._startPoint = [];
+        /** 实际绘制的点 */
+        this._realPoints = [];
+        /** 点元素 */
+        this._pointElements = [];
+        this._app = app;
+        this._params = Object.assign({ outFormat: "number", dotRadius: 2, dotColor: "#fff", polygonColor: "#68CCFF", polygonAlpha: 0.5 }, params);
+        this._app.stage.sortableChildren = true;
+        this._polygon = new Graphics();
+        this._app.stage.addChild(this._polygon);
+        this._polygon.zIndex = 999999;
+        this._setupListeners();
+    }
+    _setupListeners() {
+        // 监听键盘空格键按下事件
+        window.addEventListener("keydown", (event) => {
+            if (event.code === "Space") {
+                this.toggleDrawing();
+            }
+            else if (event.code === "Backspace") {
+                this._points.pop();
+                this._realPoints.pop();
+                this._drawPolygon();
+            }
+        });
+        // 监听鼠标点击事件
+        this._app.stage.eventMode = "static";
+        this._app.stage.on("pointerdown", (event) => {
+            if (this._drawing) {
+                this._addPoint(event);
+            }
+        });
+    }
+    /** @description 控制绘制开始和结束 */
+    toggleDrawing() {
+        if (this._drawing) {
+            alert("绘制结束");
+            this._points.push({ x: 0, y: 0 });
+            if (this._params.outFormat === "object") {
+                console.log(this._points);
+            }
+            else {
+                console.log(this._points.map((item) => [item.x, item.y]).flat());
+            }
+        }
+        else {
+            alert("开始绘制");
+            this._startPoint = [];
+            this._points = [];
+            this._realPoints = [];
+            this._polygon.clear();
+            this._pointElements.forEach((item) => item.destroy());
+            this._pointElements = [];
+        }
+        this._drawing = !this._drawing;
+    }
+    /** @description 添加点坐标 */
+    _addPoint(event) {
+        const x = Number(event.clientX.toFixed(0));
+        const y = Number(event.clientY.toFixed(0));
+        this._realPoints.push({ x, y });
+        // 如果是第一个点，记录为原点（0, 0）
+        if (this._startPoint.length === 0) {
+            this._startPoint = [{ x, y }];
+            this._points.push({ x: 0, y: 0 });
+        }
+        else {
+            // 计算相对于第一个点的偏移
+            const offsetX = x - this._startPoint[0].x;
+            const offsetY = y - this._startPoint[0].y;
+            // 将相对坐标添加到数组
+            this._points.push({
+                x: Number(offsetX.toFixed(0)),
+                y: Number(offsetY.toFixed(0)),
+            });
+        }
+        this._drawPolygon();
+    }
+    /** @description 绘制多边形 */
+    _drawPolygon() {
+        this._polygon.clear();
+        this._polygon.beginFill(this._params.polygonColor);
+        this._polygon.drawPolygon(this._realPoints);
+        this._polygon.endFill();
+        this._polygon.alpha = this._params.polygonAlpha;
+        //渲染点
+        this._pointElements.forEach((point) => point.destroy());
+        this._pointElements = [];
+        this._realPoints.forEach((point) => {
+            this._pointElements.push(this._drawDot(point.x, point.y));
+        });
+    }
+    /** @description 绘制一个点 */
+    _drawDot(x, y) {
+        const pointElement = new Graphics();
+        pointElement.beginFill(this._params.dotColor);
+        pointElement.drawCircle(x, y, this._params.dotRadius || 2);
+        pointElement.endFill();
+        this._app.stage.addChild(pointElement);
+        pointElement.zIndex = 999999;
+        return pointElement;
+    }
+}

package/Utils/LibPixiPromiseTickerTimeout.d.ts

@@ -0,0 +1,6 @@
+/** @description 基于 Ticker 和 Promise 的定时器
+ * @param delay 延迟时间
+ * @param callback 延迟后执行的函数
+ * @link 使用方法：https://www.npmjs.com/package/lyb-pixi-js#LibPixiPromiseTickerTimeout-TickerPromise定时器
+ */
+export declare const libPixiPromiseTickerTimeout: (delay?: number, callback?: () => void) => Promise<void>;

package/Utils/LibPixiPromiseTickerTimeout.js

@@ -0,0 +1,22 @@
+import { Ticker } from "pixi.js";
+/** @description 基于 Ticker 和 Promise 的定时器
+ * @param delay 延迟时间
+ * @param callback 延迟后执行的函数
+ * @link 使用方法：https://www.npmjs.com/package/lyb-pixi-js#LibPixiPromiseTickerTimeout-TickerPromise定时器
+ */
+export const libPixiPromiseTickerTimeout = (delay = 1, callback) => {
+    return new Promise((resolve) => {
+        let elapsedTime = 0;
+        const ticker = Ticker.shared;
+        const tickerCallback = () => {
+            elapsedTime += ticker.deltaMS;
+            if (elapsedTime >= delay) {
+                callback === null || callback === void 0 ? void 0 : callback();
+                ticker.remove(tickerCallback);
+                resolve();
+            }
+        };
+        ticker.add(tickerCallback);
+        ticker.start();
+    });
+};

package/Utils/LibPixiScaleContainer.d.ts

@@ -0,0 +1,8 @@
+import type { Container, Sprite, Text } from "pixi.js";
+/** @description 元素超过指定宽度就缩放
+ * @param scaleContainer 需要缩放的元素
+ * @param maxWidth 最大宽度
+ * @param maxHeight 最大高度
+ * @link 使用方法：https://www.npmjs.com/package/lyb-pixi-js#LibPixiScaleContainer-超出缩放
+ */
+export declare const libPixiScaleContainer: (scaleContainer: Container | Sprite | Text, maxWidth: number, maxHeight?: number) => void;

package/Utils/LibPixiScaleContainer.js

@@ -0,0 +1,14 @@
+/** @description 元素超过指定宽度就缩放
+ * @param scaleContainer 需要缩放的元素
+ * @param maxWidth 最大宽度
+ * @param maxHeight 最大高度
+ * @link 使用方法：https://www.npmjs.com/package/lyb-pixi-js#LibPixiScaleContainer-超出缩放
+ */
+export const libPixiScaleContainer = (scaleContainer, maxWidth, maxHeight) => {
+    const scaleX = (maxWidth / scaleContainer.width) * scaleContainer.scale.x;
+    const scaleY = maxHeight
+        ? (maxHeight / scaleContainer.height) * scaleContainer.scale.y
+        : scaleX;
+    const scale = Math.min(scaleX, scaleY);
+    scaleContainer.scale.set(scale > 1 ? 1 : scale);
+};

package/Utils/LibPixiShadow.d.ts

@@ -0,0 +1,17 @@
+import type { Container } from "pixi.js";
+export interface LibPixiShadowShadowConfig {
+    color?: string;
+    alpha?: number;
+    blur?: number;
+    distance?: number;
+    offset?: {
+        x: number;
+        y: number;
+    };
+}
+/** @description 为图片或容器设置阴影
+ * @param container 需要添加阴影的元素
+ * @param config 配置项
+ * @link 使用方法：https://www.npmjs.com/package/lyb-pixi-js#LibPixiShadow-阴影
+ */
+export declare const libPixiShadow: (container: Container, config?: LibPixiShadowShadowConfig) => void;

package/Utils/LibPixiShadow.js

@@ -0,0 +1,18 @@
+import { DropShadowFilter } from "@pixi/filter-drop-shadow";
+/** @description 为图片或容器设置阴影
+ * @param container 需要添加阴影的元素
+ * @param config 配置项
+ * @link 使用方法：https://www.npmjs.com/package/lyb-pixi-js#LibPixiShadow-阴影
+ */
+export const libPixiShadow = (container, config) => {
+    const { color = "#000", alpha = 0.25, blur = 1, distance = 0, offset = { x: 0, y: 0 }, } = config || {};
+    const shadowFilter = new DropShadowFilter({
+        color: color,
+        alpha,
+        blur,
+        distance,
+        offset,
+    });
+    shadowFilter.resolution = window.devicePixelRatio || 1;
+    container.filters = [shadowFilter];
+};