@rings-webgpu/core 1.0.6 → 1.0.7

package/dist/types/core/pool/ObjectPool.d.ts

@@ -0,0 +1,11 @@
+export declare class PoolNode<T> {
+    private _use;
+    private _unUse;
+    constructor();
+    pushBack(node: T): void;
+    getUseList(): T[];
+    getOne(instance: {
+        new (arg?: any): T;
+    }, param?: any): T;
+    hasFree(): boolean;
+}

package/dist/types/core/pool/memory/MemoryDO.d.ts

@@ -0,0 +1,10 @@
+import { MemoryInfo } from "./MemoryInfo";
+export declare class MemoryDO {
+    shareDataBuffer: ArrayBuffer;
+    private _byteOffset;
+    allocation(byteSize: number): void;
+    allocation_node(byteSize: number): MemoryInfo;
+    allocation_memory(memoryInfo: MemoryInfo): MemoryInfo;
+    reset(): void;
+    destroy(force?: boolean): void;
+}

package/dist/types/core/pool/memory/MemoryInfo.d.ts

@@ -0,0 +1,79 @@
+import { FloatArray } from "@rings/wasm-matrix/WasmMatrix";
+import { Color } from "../../../math/Color";
+import { Quaternion } from "../../../math/Quaternion";
+import { Vector2 } from "../../../math/Vector2";
+import { Vector3 } from "../../../math/Vector3";
+import { Vector4 } from "../../../math/Vector4";
+export declare class MemoryInfo {
+    byteOffset: number;
+    byteSize: number;
+    offset: number;
+    dataBytes: DataView;
+    get x(): number;
+    set x(v: number);
+    get y(): number;
+    set y(v: number);
+    get z(): number;
+    set z(v: number);
+    get w(): number;
+    set w(v: number);
+    setX(x: number): void;
+    setXY(x: number, y: number): void;
+    setXYZ(x: number, y: number, z: number): void;
+    setXYZW(x: number, y: number, z: number, w: number): void;
+    setVector2Array(vs: Vector2[]): void;
+    setVector3Array(vs: Vector3[]): void;
+    setVector4Array(vs: Vector3[] | Vector4[] | Quaternion[]): void;
+    setColorArray(colorArray: Color[]): void;
+    setInt8(v: number, index?: number): void;
+    getInt8(index?: number): number;
+    setInt16(v: number, index?: number): void;
+    getInt16(index?: number): number;
+    setInt32(v: number, index?: number): void;
+    getInt32(index?: number): number;
+    setFloat(v: number, index?: number): void;
+    getFloat(index?: number): number;
+    setUint8(v: number, index?: number): void;
+    getUint8(index?: number): number;
+    setUint16(v: number, index?: number): void;
+    getUint16(index?: number): number;
+    setUint32(v: number, index?: number): void;
+    getUint32(index?: number): number;
+    setArray(index: number, data: number[]): void;
+    setFloat32Array(index: number, data: Float32Array): void;
+    setFloatArray(index: number, value: FloatArray): void;
+    setArrayBuffer(index: number, arrayBuffer: ArrayBuffer): void;
+    setInt8Array(index: number, data: Int8Array): void;
+    setInt16Array(index: number, data: Int16Array): void;
+    setInt32Array(index: number, data: Int32Array): void;
+    setUint8Array(index: number, data: Uint8Array): void;
+    setUint16Array(index: number, data: Uint16Array): void;
+    setUint32Array(index: number, data: Uint32Array): void;
+    setData(index: number, data: number): void;
+    setVector2(index: number, data: Vector2): void;
+    setVector3(index: number, data: Vector3): void;
+    setVector4(index: number, data: Vector4): void;
+    setColor(index: number, data: Color): void;
+    getData(index: number): number;
+    writeFloat(v: number): void;
+    writeInt8(v: number): void;
+    writeInt16(v: number): void;
+    writeInt32(v: number): void;
+    writeUint8(v: number): void;
+    writeUint16(v: number): void;
+    writeUint32(v: number): void;
+    writeVector2(v: Vector2): void;
+    writeVector3(v: Vector3): void;
+    writeVector4(v: Vector4): void;
+    writeRGBColor(v: Color): void;
+    writeArray(v: number[]): void;
+    writeFloat32Array(v: Float32Array): void;
+    writeInt8Array(v: Int8Array): void;
+    writeInt16Array(v: Int16Array): void;
+    writeInt32Array(v: Int32Array): void;
+    writeUint8Array(v: Uint8Array): void;
+    writeUint16Array(v: Uint16Array): void;
+    writeUint32Array(v: Uint32Array): void;
+    reset(): void;
+    destroy(): void;
+}

package/dist/types/core/tree/kdTree/IKDTreeUserData.d.ts

@@ -0,0 +1,10 @@
+import { RenderNode } from "../../../components/renderer/RenderNode";
+import { KDTreeEntity } from "../kdTree/KDTreeEntity";
+/**
+ * @internal
+ * @group Core
+ */
+export declare class IKDTreeUserData {
+    get data(): RenderNode;
+    entity: KDTreeEntity;
+}

package/dist/types/core/tree/kdTree/KDTreeEntity.d.ts

@@ -0,0 +1,27 @@
+import { Ray } from "../../../math/Ray";
+import { Vector3 } from "../../../math/Vector3";
+import { BoundingBox } from "../../bound/BoundingBox";
+import { IKDTreeUserData } from "./IKDTreeUserData";
+import { KDTreeNode, KDTreeUUID } from "./KDTreeNode";
+/**
+ * @internal
+ * @group Core
+ */
+export declare class KDTreeEntity extends KDTreeUUID {
+    readonly userData: IKDTreeUserData;
+    node: KDTreeNode;
+    constructor(data: IKDTreeUserData);
+    centerValue(dimension: string): number;
+    isInNode(node: KDTreeNode, dimension: string): boolean;
+    entityContainPoint(point: {
+        [p: string]: number;
+    }): boolean;
+    squareDistanceTo(point: {
+        [p: string]: number;
+    }, dimensions: string[]): number;
+    entityIntersectsBox(box: BoundingBox): boolean;
+    entityIntersectsRay(ray: Ray, target: Vector3): boolean;
+    attachTreeNode(node: KDTreeNode): boolean;
+    detachTreeNode(): boolean;
+    updateNode(root: KDTreeNode): void;
+}

package/dist/types/core/tree/kdTree/KDTreeNode.d.ts

@@ -0,0 +1,68 @@
+import { Ray } from "../../../math/Ray";
+import { Vector3 } from "../../../math/Vector3";
+import { BoundingBox } from "../../bound/BoundingBox";
+import { IKDTreeUserData } from "./IKDTreeUserData";
+import { KDTreeEntity } from "./KDTreeEntity";
+import { KDTreeSpace } from "./KDTreeSpace";
+/**
+ * @internal
+ * @group Core
+ */
+export declare class KDTreeUUID {
+    private static UUID;
+    readonly uuid: string;
+    constructor();
+}
+/**
+ * @internal
+ * @group Core
+ */
+declare class KDTreeNodeMap {
+    map: {
+        [key: string]: KDTreeEntity;
+    };
+    private _count;
+    get count(): number;
+    push(entity: KDTreeEntity): boolean;
+    remove(uuid: string): boolean;
+}
+/**
+ * @internal
+ * @group Core
+ */
+export declare class KDTreeNode extends KDTreeUUID {
+    protected _dimensionIndex: number;
+    protected _dimensions: string[];
+    protected _dimension: string;
+    protected _left: KDTreeNode;
+    protected _right: KDTreeNode;
+    protected _space: KDTreeSpace;
+    protected _parent: KDTreeNode;
+    protected _entities: KDTreeNodeMap;
+    protected readonly layer: any;
+    get dimension(): string;
+    constructor(layer?: number);
+    initNode(parent: KDTreeNode, dimensions: string[], index: number): this;
+    updateEntity(entity: KDTreeEntity): void;
+    buildRoot(list: IKDTreeUserData[]): void;
+    private _splitEntityList;
+    protected autoSplit(): void;
+    protected setSpace(less: boolean, value: number): this;
+    protected isEmpty(): boolean;
+    pushEntity(entity: KDTreeEntity): boolean;
+    removeEntity(entity: KDTreeEntity): boolean;
+    static nodeCount: number;
+    autoClear(): void;
+    protected clearLeaf(): boolean;
+    isContain(value: number): boolean;
+    private static rangeBox;
+    protected nodeIntersectsBox(box: BoundingBox): boolean;
+    protected nodeIntersectsRay(ray: Ray): boolean;
+    pointCast(point: {
+        [key: string]: number;
+    }, squareDistance?: number, ret?: KDTreeEntity[]): void;
+    boxCast(box: BoundingBox, ret?: KDTreeEntity[]): void;
+    private pointIntersect;
+    rayCast(ray: Ray, ret?: KDTreeEntity[], pts?: Vector3[]): void;
+}
+export {};

package/dist/types/core/tree/kdTree/KDTreeSpace.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @internal
+ * @group Core
+ */
+export declare class KDTreeRange {
+    min: number;
+    max: number;
+    set(min: number, max: number): this;
+    copy(src: KDTreeRange): this;
+    isInterestRange(src: KDTreeRange): boolean;
+}
+/**
+ * @internal
+ * @group Core
+ */
+export declare class KDTreeSpace {
+    protected _spaceDesc: {
+        [key: string]: KDTreeRange;
+    };
+    getRange(dimension: string): KDTreeRange;
+    initSpace(dimensions: string[]): this;
+    isContain(dimension: string, value: number): boolean;
+    isInterestRange(dimension: string, range1: KDTreeRange): boolean;
+    splitSpace(dimension: string, less: boolean, value: number): this;
+    copySpace(space: KDTreeSpace): this;
+}

package/dist/types/core/tree/octree/Octree.d.ts

@@ -0,0 +1,28 @@
+import { CollectInfo } from "../../..";
+import { Ray } from "../../../math/Ray";
+import { Vector3 } from "../../../math/Vector3";
+import { BoundingBox } from "../../bound/BoundingBox";
+import { Frustum } from "../../bound/Frustum";
+import { OctreeEntity } from "./OctreeEntity";
+export declare class Octree {
+    private static _v1;
+    private static _v2;
+    readonly entities: Map<string, OctreeEntity>;
+    readonly box: BoundingBox;
+    readonly subTrees: Octree[];
+    readonly parent: Octree;
+    readonly level: number;
+    static readonly maxSplitLevel = 6;
+    private static readonly autoSplitLevel;
+    readonly index: number;
+    readonly uuid: string;
+    constructor(size: BoundingBox, index?: number, parent?: Octree, level?: number);
+    tryInsertEntity(entity: OctreeEntity): boolean;
+    private splitTree;
+    __rayCastTempVector: Vector3;
+    rayCasts(ray: Ray, ret: OctreeEntity[]): boolean;
+    frustumCasts(frustum: Frustum, ret: OctreeEntity[]): boolean;
+    getRenderNode(frustum: Frustum, ret: CollectInfo): boolean;
+    boxCasts(box: BoundingBox, ret: OctreeEntity[]): boolean;
+    clean(): this;
+}

package/dist/types/core/tree/octree/OctreeEntity.d.ts

@@ -0,0 +1,11 @@
+import { RenderNode } from "../../../components/renderer/RenderNode";
+import { Octree } from "./Octree";
+export declare class OctreeEntity {
+    readonly renderer: RenderNode;
+    owner: Octree;
+    readonly uuid: string;
+    constructor(renderer: RenderNode);
+    leaveNode(): void;
+    enterNode(node: Octree): void;
+    update(root: Octree): Octree;
+}

package/dist/types/core/tree/quad/IQuadNode.d.ts

@@ -0,0 +1,9 @@
+import { Plane3D } from "../../../math/Plane3D";
+import { QuadAABB } from "./QuadAABB";
+export interface IQuadNode {
+    initAABB(): void;
+    isTriangle: boolean;
+    aabb: QuadAABB;
+    calcGlobalQuadAABB(): void;
+    plane?: Plane3D;
+}

package/dist/types/core/tree/quad/QuadAABB.d.ts

@@ -0,0 +1,26 @@
+import { Vector3 } from "../../../math/Vector3";
+export declare class QuadAABB {
+    minPosX: number;
+    minPosY: number;
+    maxPosX: number;
+    maxPosY: number;
+    testID: number;
+    points: Array<Vector3>;
+    private offsetPosition;
+    private static TINY;
+    constructor();
+    setAABox(cx: number, cy: number, sideX: number, sideY: number): void;
+    setOffset(vec: Vector3): void;
+    setContainRect(minX: number, minY: number, maxX: number, maxY: number): void;
+    clear(): void;
+    addPoint(pos: Vector3): void;
+    clone(): QuadAABB;
+    get radius(): number;
+    get sideX(): number;
+    get sideY(): number;
+    get centreX(): number;
+    get centreY(): number;
+    overlapTest(box: QuadAABB): boolean;
+    isPointInside(pos: Vector3): boolean;
+    isIntersectLineSegment(p1x: number, p1y: number, p2x: number, p2y: number): boolean;
+}

package/dist/types/core/tree/quad/QuadRoot.d.ts

@@ -0,0 +1,14 @@
+import { Vector3 } from "../../../math/Vector3";
+import { IQuadNode } from "./IQuadNode";
+export declare class QuadRoot {
+    private _maxNodesPerCell;
+    private _minCellSize;
+    private _quadTree;
+    private _collisionNodesIdx;
+    private _segBox;
+    private _collisionNodes;
+    constructor(maxNodesPerCell?: number, minCellSize?: number);
+    createQuadTree(nodes: Array<IQuadNode>): void;
+    getNodesByAABB(minX: number, minY: number, maxX: number, maxY: number): Array<IQuadNode>;
+    getTriangleAtPoint(point: Vector3, threshold?: number): IQuadNode;
+}

package/dist/types/core/tree/quad/QuadTree.d.ts

@@ -0,0 +1,22 @@
+import { IQuadNode } from "./IQuadNode";
+import { QuadAABB } from "./QuadAABB";
+export declare class QuadTree {
+    private _cells;
+    private _rootCell;
+    private _quadNodes;
+    private _aabb;
+    private _cellsToTest;
+    private _testID;
+    constructor();
+    getQuadNode(idx: number): IQuadNode;
+    clear(): void;
+    initNodes(nodes: Array<IQuadNode>): void;
+    buildQuadTree(maxNodesPerCell: number, minCellSize: number): void;
+    private createAABox;
+    private doesNodeIntersectCell;
+    getNodesIntersectingtAABox(result: Array<number>, aabb: QuadAABB): number;
+    private pointInTriangle;
+    private incrementTestCounter;
+    private logDeep;
+    private logTree;
+}

package/dist/types/core/tree/quad/QuadTreeCell.d.ts

@@ -0,0 +1,23 @@
+import { Vector3 } from "../../../math/Vector3";
+import { QuadAABB } from "./QuadAABB";
+/**
+ * 四叉树节点单元类
+ * 用于构建四叉树空间索引结构的基本单元
+ */
+export declare class QuadTreeCell {
+    static NUM_CHILDREN: number;
+    childCellIndices: Array<number>;
+    nodeIndices: Array<number>;
+    aabb: QuadAABB;
+    points: Array<Vector3>;
+    constructor(aabox: QuadAABB);
+    /**
+     * 判断是否为叶节点
+     * @returns 如果是叶节点（不包含子节点）返回true
+     *
+     * @注 叶节点意味着当前节点包含实际对象数据，
+     * 而非叶节点则应该包含子节点（可能同时包含对象数据）
+     */
+    isLeaf(): boolean;
+    clear(): void;
+}

package/dist/types/event/CEvent.d.ts

@@ -0,0 +1,27 @@
+import { View3D } from "../core/View3D";
+import { Object3D } from "../core/entities/Object3D";
+import { TouchData } from "../io/TouchData";
+import { CEventListener } from "./CEventListener";
+export declare class CEvent {
+    target: Object3D;
+    currentTarget: CEventListener;
+    type: string | null;
+    data?: any;
+    param: any;
+    time: number;
+    delay: number;
+    mouseCode: number;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    altKey: boolean;
+    shiftKey: boolean;
+    targetTouches: Array<TouchData>;
+    changedTouches: Array<TouchData>;
+    touches: Array<TouchData>;
+    private _stopImmediatePropagation;
+    view: View3D;
+    constructor(eventType?: string | null, data?: any);
+    stopImmediatePropagation(): void;
+    reset(): void;
+    get isStopImmediatePropagation(): boolean;
+}

package/dist/types/event/CEventDispatcher.d.ts

@@ -0,0 +1,13 @@
+import { CEvent } from "./CEvent";
+export declare class CEventDispatcher {
+    protected listeners: any;
+    data: any;
+    dispatchEvent(event: CEvent): void;
+    destroy(): void;
+    addEventListener(type: string | number, callback: Function, thisObject: any, param?: any, priority?: number): number;
+    removeEventListener(type: string | number, callback: Function, thisObject: any): void;
+    removeEventListenerAt(id: number): boolean;
+    removeAllEventListener(eventType?: string | number | null): void;
+    containEventListener(type: string): boolean;
+    hasEventListener(type: string | number, callback?: Function | null, thisObject?: any): boolean;
+}

package/dist/types/event/CEventListener.d.ts

@@ -0,0 +1,13 @@
+export declare class CEventListener {
+    type: string | number | null;
+    thisObject: any;
+    handler: Function | null;
+    param: any;
+    priority: number;
+    static event_id_count: number;
+    id: number;
+    current: any;
+    constructor(type?: string | number | null, thisObject?: any, handler?: Function | null, param?: any, priority?: number);
+    equalCurrentListener(type: string | number, handler: Function, thisObject: any, param: any): boolean;
+    dispose(): void;
+}

package/dist/types/event/CResizeEvent.d.ts

@@ -0,0 +1,4 @@
+import { CEvent } from "./CEvent";
+export declare class CResizeEvent extends CEvent {
+    static RESIZE: string;
+}

package/dist/types/event/KeyCode.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Represents a unique identifier corresponding to a keyboard button. see {@link KeyboardEvent.keyCode}
+ * @group Events
+ */
+export declare enum KeyCode {
+    Key_BackSpace = 8,
+    Key_Tab = 9,
+    Key_Clear = 12,
+    Key_Enter = 13,
+    Key_Shift_L = 16,
+    Key_Control_L = 17,
+    Key_Alt_L = 18,
+    Key_Pause = 19,
+    Key_CapsLock = 20,
+    Key_Escape = 21,
+    Key_Esc = 27,
+    Key_Space = 32,
+    Key_Prior = 33,
+    Key_Next = 34,
+    Key_End = 35,
+    Key_Home = 36,
+    Key_Left = 37,
+    Key_Up = 38,
+    Key_Right = 39,
+    Key_Down = 40,
+    Key_Select = 41,
+    Key_Print = 42,
+    Key_Execute = 43,
+    Key_Insert = 45,
+    Key_Delete = 46,
+    Key_Help = 47,
+    Key_0 = 48,
+    Key_1 = 49,
+    Key_2 = 50,
+    Key_3 = 51,
+    Key_4 = 52,
+    Key_5 = 53,
+    Key_6 = 54,
+    Key_7 = 55,
+    Key_8 = 56,
+    Key_9 = 57,
+    Key_A = 65,
+    Key_B = 66,
+    Key_C = 67,
+    Key_D = 68,
+    Key_E = 69,
+    Key_F = 70,
+    Key_G = 71,
+    Key_H = 72,
+    Key_I = 73,
+    Key_J = 74,
+    Key_K = 75,
+    Key_L = 76,
+    Key_M = 77,
+    Key_N = 78,
+    Key_O = 79,
+    Key_P = 80,
+    Key_Q = 81,
+    Key_R = 82,
+    Key_S = 83,
+    Key_T = 84,
+    Key_U = 85,
+    Key_V = 86,
+    Key_W = 87,
+    Key_X = 88,
+    Key_Y = 89,
+    Key_Z = 90,
+    Key_KP_0 = 96,
+    Key_KP_1 = 97,
+    Key_KP_2 = 98,
+    Key_KP_3 = 99,
+    Key_KP_4 = 100,
+    Key_KP_5 = 101,
+    Key_KP_6 = 102,
+    Key_KP_7 = 103,
+    Key_KP_8 = 104,
+    Key_KP_9 = 105,
+    Key_Multiply = 106,
+    Key_Add = 107,
+    Key_Separator = 108,
+    Key_Subtract = 109,
+    Key_Decimal = 110,
+    Key_Divide = 111,
+    Key_F1 = 112,
+    Key_F2 = 113,
+    Key_F3 = 114,
+    Key_F4 = 115,
+    Key_F5 = 116,
+    Key_F6 = 117,
+    Key_F7 = 118,
+    Key_F8 = 119,
+    Key_F9 = 120,
+    Key_F10 = 121,
+    Key_F11 = 122,
+    Key_F12 = 123,
+    Key_F13 = 124,
+    Key_F14 = 125,
+    Key_F15 = 126,
+    Key_F16 = 127,
+    Key_F17 = 128,
+    Key_F18 = 129,
+    Key_F19 = 130,
+    Key_F20 = 131,
+    Key_F21 = 132,
+    Key_F22 = 133,
+    Key_F23 = 134,
+    Key_F24 = 135,
+    Key_Num_Lock = 136,
+    Key_Scroll_Lock = 137
+}

package/dist/types/event/MouseCode.d.ts

@@ -0,0 +1,5 @@
+export declare enum MouseCode {
+    MOUSE_LEFT = 0,
+    MOUSE_MID = 1,
+    MOUSE_RIGHT = 2
+}

package/dist/types/event/eventConst/KeyEvent.d.ts

@@ -0,0 +1,6 @@
+import { CEvent } from "../CEvent";
+export declare class KeyEvent extends CEvent {
+    static KEY_DOWN: string;
+    static KEY_UP: string;
+    keyCode: number;
+}

package/dist/types/event/eventConst/LoaderEvent.d.ts

@@ -0,0 +1,5 @@
+import { CEvent } from "../CEvent";
+export declare class LoaderEvent extends CEvent {
+    static LOADER_PROGRESS: string;
+    static LOADER_COMPLETE: string;
+}

package/dist/types/event/eventConst/Object3DEvent.d.ts

@@ -0,0 +1,7 @@
+import { CEvent } from "../CEvent";
+export declare class Object3DEvent extends CEvent {
+    static ADDED: string;
+    static REMOVED: string;
+    static CHILD_ADD_EVENT: string;
+    static CHILD_REMOVED: string;
+}

package/dist/types/event/eventConst/PointerEvent3D.d.ts

@@ -0,0 +1,63 @@
+import { GUIHitInfo } from "../../components/gui/uiComponents/IUIInteractive";
+import { Vector2 } from "../../math/Vector2";
+import { Vector3 } from "../../math/Vector3";
+import { CEvent } from "../CEvent";
+type pickResult = {
+    meshID: number;
+    worldPos: Vector3;
+    worldNormal: Vector3;
+    screenUv?: Vector2;
+    distance?: number;
+};
+export declare class PointerEvent3D extends CEvent {
+    static PICK_OVER: string;
+    static PICK_CLICK: string;
+    static PICK_OUT: string;
+    static PICK_MOVE: string;
+    static PICK_UP: string;
+    static PICK_DOWN: string;
+    static POINTER_RIGHT_CLICK: string;
+    static POINTER_MID_UP: string;
+    static POINTER_MID_DOWN: string;
+    static POINTER_CLICK: string;
+    static POINTER_MOVE: string;
+    static POINTER_DOWN: string;
+    static POINTER_UP: string;
+    static POINTER_OUT: string;
+    static POINTER_OVER: string;
+    static POINTER_WHEEL: string;
+    pointerId: number;
+    pointerType: string;
+    isPrimary: boolean;
+    pressure: number;
+    mouseX: number;
+    mouseY: number;
+    movementX: number;
+    movementY: number;
+    deltaX: number;
+    deltaY: number;
+    data: pickResult;
+    deltaZ: number;
+    reset(): void;
+}
+export declare class PickGUIEvent3D extends CEvent {
+    static PICK_OVER_GUI: string;
+    static PICK_CLICK_GUI: string;
+    static PICK_OUT_GUI: string;
+    static PICK_UP_GUI: string;
+    static PICK_DOWN_GUI: string;
+    pointerId: number;
+    pointerType: string;
+    isPrimary: boolean;
+    pressure: number;
+    mouseX: number;
+    mouseY: number;
+    movementX: number;
+    movementY: number;
+    deltaX: number;
+    deltaY: number;
+    data: GUIHitInfo;
+    deltaZ: number;
+    reset(): void;
+}
+export {};

package/dist/types/event/eventConst/UIEvent.d.ts

@@ -0,0 +1,6 @@
+import { CEvent } from "../CEvent";
+export declare class UIEvent extends CEvent {
+    static SHOW: string;
+    static HIDE: string;
+    static UPDATE: string;
+}

package/dist/types/gfx/generate/BrdfLUTGenerate.d.ts

@@ -0,0 +1,7 @@
+import { VirtualTexture } from "../../textures/VirtualTexture";
+import { ComputeShader } from "../graphics/webGpu/shader/ComputeShader";
+export declare class BRDFLUTGenerate {
+    compute: ComputeShader;
+    constructor();
+    generateBRDFLUTTexture(): VirtualTexture;
+}

package/dist/types/gfx/generate/PassGenerate.d.ts

@@ -0,0 +1,9 @@
+import { RenderNode } from "../../components/renderer/RenderNode";
+import { Shader } from "../graphics/webGpu/shader/Shader";
+export declare class PassGenerate {
+    static createGIPass(renderNode: RenderNode, shader: Shader): void;
+    static castGBufferPass(renderNode: RenderNode, shader: Shader): void;
+    static createShadowPass(renderNode: RenderNode, shader: Shader): void;
+    static createDepthPass(renderNode: RenderNode, shader: Shader): void;
+    static createReflectionPass(renderNode: RenderNode, shader: Shader): void;
+}