@rings-webgpu/core 1.0.6 → 1.0.7

package/dist/types/gfx/graphics/webGpu/shader/converter/StatementNode.d.ts

@@ -0,0 +1,309 @@
+import { GLSLLexer } from "./GLSLLexer";
+import { GLSLLexerToken } from "./GLSLLexerToken";
+import { TranslatorContext } from "./WGSLTranslator";
+/**
+ * @internal
+ * Statement node
+ * @group GFX
+ */
+export declare class StatementNode {
+    nodes: Array<StatementNode>;
+    constructor();
+    addNode(node: StatementNode): void;
+    formatToWGSL(context: TranslatorContext, depth: number): string;
+}
+/**
+ * @internal
+ * Statement node: struct
+ * @group GFX
+ */
+export declare class SN_Struct extends StatementNode {
+    name: string;
+    fields: Array<SN_Declaration>;
+    constructor(name: string);
+    static parse(r: GLSLLexer): SN_Struct;
+    formatToWGSL(context: TranslatorContext, depth: number): string;
+}
+/**
+ * @internal
+ * Statement node: function
+ * @group GFX
+ */
+export declare class SN_Function extends StatementNode {
+    name: string;
+    args: Array<SN_Declaration>;
+    body: SN_CodeBlock;
+    returnType: string;
+    constructor(name: string, args: Array<SN_Declaration>, body: SN_CodeBlock, returnType: string);
+    static parse(r: GLSLLexer): SN_Function;
+    formatToWGSL(context: TranslatorContext, depth: number): string;
+}
+/**
+ * @internal
+ * Statement node: functionArg
+ * @group GFX
+ */
+export declare class SN_FunctionArgs extends StatementNode {
+    args: Array<SN_Expression>;
+    constructor();
+    static parse(r: GLSLLexer): SN_FunctionArgs;
+}
+/**
+ * @internal
+ * Statement node: functionCall
+ * @group GFX
+ */
+export declare class SN_FunctionCall extends StatementNode {
+    name: string;
+    args: SN_FunctionArgs;
+    constructor(name: string, args: SN_FunctionArgs);
+    static parse(r: GLSLLexer): SN_FunctionCall;
+    formatToWGSL(context: TranslatorContext, depth: number): string;
+}
+/**
+ * @internal
+ * Statement node: declaration
+ * @group GFX
+ */
+export declare class SN_Declaration extends StatementNode {
+    type: string;
+    name: string;
+    arraySize: SN_Expression;
+    hasIn: boolean;
+    hasOut: boolean;
+    hasConst: boolean;
+    constructor(type: string, name: string, arraySize?: SN_Expression);
+    static parse(r: GLSLLexer): SN_Declaration;
+    formatToWGSL(context: TranslatorContext, depth: number): string;
+}
+/**
+ * @internal
+ * Statement node: for
+ * @group GFX
+ */
+export declare class SN_ForLoop extends StatementNode {
+    expression1: StatementNode;
+    condition: SN_Expression;
+    expression2: SN_Expression;
+    loopBody: SN_CodeBlock;
+    constructor(expression1: StatementNode, condition: SN_Expression, expression2: SN_Expression, loopBody: SN_CodeBlock);
+    static parse(r: GLSLLexer): SN_ForLoop;
+    formatToWGSL(context: TranslatorContext, depth: number): string;
+}
+/**
+ * @internal
+ * Statement node: while
+ * @group GFX
+ */
+export declare class SN_WhileLoop extends StatementNode {
+    conditionExpr: SN_Expression;
+    loopBody: SN_CodeBlock;
+    constructor(condition: SN_Expression, loopBody: SN_CodeBlock);
+    static parse(r: GLSLLexer): SN_WhileLoop;
+    formatToWGSL(context: TranslatorContext, depth: number): string;
+}
+/**
+ * @internal
+ * Statement node: do-while
+ * @group GFX
+ */
+export declare class SN_DoWhileLoop extends StatementNode {
+    constructor();
+}
+/**
+ * @internal
+ * Statement node: if
+ * @group GFX
+ */
+export declare class SN_IFBranch extends StatementNode {
+    conditionExpr: SN_Expression;
+    trueBranch: SN_CodeBlock;
+    falseBranch: SN_CodeBlock;
+    constructor(condition: SN_Expression, trueBranch: SN_CodeBlock, falseBranch: SN_CodeBlock);
+    static parse(r: GLSLLexer): SN_IFBranch;
+    formatToWGSL(context: TranslatorContext, depth: number): string;
+}
+/**
+ * @internal
+ * Statement node: expression
+ * @group GFX
+ */
+export declare class SN_Expression extends StatementNode {
+    constructor();
+    static parse(r: GLSLLexer): SN_Expression;
+    formatToWGSL(context: TranslatorContext, depth: number): string;
+    protected static unionOperation(opStack: Array<GLSLLexerToken>, valueStack: Array<any>): boolean;
+}
+/**
+ * @internal
+ * Statement node: Paren expression
+ * @group GFX
+ */
+export declare class SN_ParenExpression extends StatementNode {
+    constructor();
+    formatToWGSL(context: TranslatorContext, depth: number): string;
+}
+/**
+ * @internal
+ * Statement node: identifier
+ * @group GFX
+ */
+export declare class SN_Identifier extends StatementNode {
+    name: string;
+    constructor(name: string);
+    formatToWGSL(context: TranslatorContext, depth: number): string;
+}
+/**
+ * @internal
+ * Statement node: constant
+ * @group GFX
+ */
+export declare class SN_Constant extends StatementNode {
+    value: string;
+    constructor(value: string);
+    static parse(r: GLSLLexer): SN_Constant;
+    formatToWGSL(context: TranslatorContext, depth: number): string;
+}
+/**
+ * @internal
+ * Statement node: array constant
+ * @group GFX
+ */
+export declare class SN_ArrayConstant extends SN_Constant {
+    arrayValue: SN_Constant[];
+    constructor(value: SN_Constant[]);
+    static parse(r: GLSLLexer): SN_ArrayConstant;
+    formatToWGSL(context: TranslatorContext, depth: number): string;
+}
+/**
+ * @internal
+ * Statement node: process control(break)
+ * @group GFX
+ */
+export declare class SN_Break extends StatementNode {
+    constructor();
+}
+/**
+ * @internal
+ * Statement node: process control(discard)
+ * @group GFX
+ */
+export declare class SN_Discard extends StatementNode {
+    constructor();
+}
+/**
+ * @internal
+ * Statement node: process control(continue)
+ * @group GFX
+ */
+export declare class SN_Continue extends StatementNode {
+    constructor();
+    static parse(r: GLSLLexer): SN_Continue;
+    formatToWGSL(context: TranslatorContext, depth: number): string;
+}
+/**
+ * @internal
+ * Statement node: process control(return)
+ * @group GFX
+ */
+export declare class SN_Return extends StatementNode {
+    value: SN_Expression;
+    constructor(value: SN_Expression);
+    static parse(r: GLSLLexer): SN_Return;
+    formatToWGSL(context: TranslatorContext, depth: number): string;
+}
+/**
+ * @internal
+ * Statement node: unary operation
+ * @group GFX
+ */
+export declare class SN_UnaryOperation extends StatementNode {
+    op: GLSLLexerToken;
+    leftValue: StatementNode | undefined;
+    rightValue: StatementNode | undefined;
+    constructor(op: GLSLLexerToken, lValue: StatementNode | undefined, rValue: StatementNode | undefined);
+    formatToWGSL(context: TranslatorContext, depth: number): string;
+}
+/**
+ * @internal
+ * Statement node: binary operation
+ * @group GFX
+ */
+export declare class SN_BinaryOperation extends StatementNode {
+    op: GLSLLexerToken;
+    leftValue: StatementNode;
+    rightValue: StatementNode;
+    constructor(op: GLSLLexerToken, lValue: StatementNode, rValue: StatementNode);
+    formatToWGSL(context: TranslatorContext, depth: number): string;
+}
+/**
+ * @internal
+ * Statement node: ternary operation
+ * @group GFX
+ */
+export declare class SN_TernaryOperation extends StatementNode {
+    condition: SN_Expression;
+    expression1: SN_Expression;
+    expression2: SN_Expression;
+    constructor(condition: SN_Expression, expression1: SN_Expression, expression2: SN_Expression);
+    static parse(r: GLSLLexer): SN_TernaryOperation;
+    formatToWGSL(context: TranslatorContext, depth: number): string;
+}
+/**
+ * @internal
+ * Statement node: Expression of select(a.b)
+ * @group GFX
+ */
+export declare class SN_SelectOperation extends StatementNode {
+    leftValue: StatementNode;
+    rightValue: StatementNode;
+    constructor(lValue: StatementNode, rValue: StatementNode);
+    static parse(r: GLSLLexer): SN_SelectOperation;
+    formatToWGSL(context: TranslatorContext, depth: number): string;
+}
+/**
+ * @internal
+ * Statement node: Expression of index(a[b])
+ * @group GFX
+ */
+export declare class SN_IndexOperation extends StatementNode {
+    leftValue: StatementNode;
+    indexValue: StatementNode;
+    constructor(lValue: StatementNode, indexValue: StatementNode);
+    static parse(r: GLSLLexer): SN_IndexOperation;
+    formatToWGSL(context: TranslatorContext, depth: number): string;
+}
+/**
+ * @internal
+ * Statement node: code block
+ * @group GFX
+ */
+export declare class SN_CodeBlock extends StatementNode {
+    constructor();
+    static parse(r: GLSLLexer): SN_CodeBlock;
+}
+/**
+ * @internal
+ * Statement node: precision
+ * @group GFX
+ */
+export declare class SN_Precision extends StatementNode {
+    type: string;
+    qualifier: string;
+    constructor(qualifier: string, type: string);
+    static parse(r: GLSLLexer): SN_Precision;
+    formatToWGSL(context: TranslatorContext, depth: number): string;
+}
+/**
+ * @internal
+ * Statement node: layout
+ * @group GFX
+ */
+export declare class SN_Layout extends StatementNode {
+    scope: string;
+    qualifier: Map<string, string>;
+    constructor();
+    addQualifier(name: string, value?: string): void;
+    static parse(r: GLSLLexer): SN_Layout;
+    formatToWGSL(context: TranslatorContext, depth: number): string;
+}

package/dist/types/gfx/graphics/webGpu/shader/converter/WGSLTranslator.d.ts

@@ -0,0 +1,50 @@
+import { GLSLSyntax } from "./GLSLSyntax";
+import { ShaderConverterResult } from "./ShaderConverter";
+import { SN_Layout, StatementNode } from "./StatementNode";
+/**
+ * @internal
+ * WGSLCode Translator
+ * @group GFX
+ */
+export declare class WGSLTranslator {
+    result: string;
+    ASTRoot: StatementNode;
+    protected _syntax: GLSLSyntax;
+    constructor(syntax: GLSLSyntax);
+    /**
+     * Generate WGSL code
+     * @returns WGSL code
+     */
+    generateWGSL(): ShaderConverterResult;
+}
+/**
+ * The translator context
+ * @internal
+ * @group GFX
+ */
+export declare class TranslatorContext {
+    protected _stage: string;
+    protected _builtinIn: Array<string>;
+    protected _builtinOut: Array<string>;
+    protected _layoutsIn: Array<SN_Layout>;
+    protected _layoutsOut: Array<SN_Layout>;
+    protected _layoutUniformCount: number;
+    protected _workGroupSize: SN_Layout;
+    protected _parentContext?: TranslatorContext;
+    protected _identifierEnv: Map<string, string>;
+    constructor(context?: TranslatorContext);
+    get stage(): string;
+    set stage(value: string);
+    get builtinIn(): Array<string>;
+    get builtinOut(): Array<string>;
+    get layoutsIn(): Array<SN_Layout>;
+    get layoutsOut(): Array<SN_Layout>;
+    get layoutUniformCount(): number;
+    set layoutUniformCount(value: number);
+    get workGroupSize(): SN_Layout;
+    set workGroupSize(value: SN_Layout);
+    get parentContext(): TranslatorContext | undefined;
+    findIdentifier(name: string): string;
+    addIdentifier(name: string, value: string): void;
+    hasIdentifier(name: string): boolean;
+}

package/dist/types/gfx/graphics/webGpu/shader/util/MorePassParser.d.ts

@@ -0,0 +1,25 @@
+export declare class MorePassShader {
+    name: string;
+    passMap: Map<string, PassShader[]>;
+}
+export declare class PassShader {
+    passType: string;
+    shaderState: Map<string, any>;
+    vertexShader: string;
+    fragmentShader: string;
+}
+export declare class MorePassParser {
+    protected static passKeyword: string;
+    protected static shaderKeyword: string;
+    protected static vertexKeyword: string;
+    protected static fragmentKeyword: string;
+    protected static passTypeKeyword: string;
+    static parser(code: string, defineValue: {
+        [name: string]: any;
+    }): MorePassShader;
+    protected static splitPassBlock(code: string): string[];
+    protected static parserPassBlock(code: string): PassShader;
+    protected static parserShaderState(passShader: PassShader, code: string): boolean;
+    protected static convertValue(str: string): number | boolean | string;
+    private static extractBlock;
+}

package/dist/types/gfx/graphics/webGpu/shader/util/Preprocessor.d.ts

@@ -0,0 +1,28 @@
+export declare class Preprocessor {
+    static parse(code: string, defineValue: {
+        [name: string]: any;
+    }): string;
+    static parseComputeShader(code: string, defineValue: {
+        [name: string]: any;
+    }): string;
+    protected static parsePreprocess(context: PreprocessorContext, code: string, defineValue: {
+        [name: string]: any;
+    }): string;
+    protected static parseAutoBindingForAllGroup(code: string): string;
+    protected static parseAutoBindingForGroupX(code: string, nGroup: number): string;
+    protected static parseAutoLocation(code: string): string;
+    protected static parseAutoLocationBlock(code: string): string;
+    protected static parsePreprocessCommand(context: PreprocessorContext, code: string, defineValue: {
+        [name: string]: any;
+    }): string;
+    protected static parseCondition(condition: string, defineValue: {
+        [name: string]: any;
+    }): boolean;
+    static filterComment(code: string): string;
+    protected static extract(str: string, leftStr: string, rightStr: string): string;
+}
+declare class PreprocessorContext {
+    includeMap: Map<string, boolean>;
+    constructor();
+}
+export {};

package/dist/types/gfx/graphics/webGpu/shader/util/ShaderUtil.d.ts

@@ -0,0 +1,23 @@
+import { RenderShaderPass } from "../RenderShaderPass";
+export type VertexPart = {
+    name: string;
+    vertex_in_struct: string;
+    vertex_out_struct: string;
+    vertex_buffer: string;
+    vertex_fun: string;
+    vertex_out: string;
+};
+export type FragmentPart = {
+    name: string;
+    fs_textures: string;
+    fs_frament: string;
+    fs_normal: string;
+    fs_shadow: string;
+    fs_buffer: string;
+    fs_frameBuffers: string;
+};
+export declare class ShaderUtil {
+    static renderShaderModulePool: Map<string, GPUShaderModule>;
+    static renderShader: Map<string, RenderShaderPass>;
+    static init(): void;
+}

package/dist/types/gfx/graphics/webGpu/shader/value/ConstValue.d.ts

@@ -0,0 +1 @@
+export type ConstValue = number | boolean;

package/dist/types/gfx/graphics/webGpu/shader/value/DefineValue.d.ts

@@ -0,0 +1,4 @@
+export type DefineValue = {
+    name: string;
+    value: number | boolean;
+};

package/dist/types/gfx/graphics/webGpu/shader/value/ShaderReflectionInfo.d.ts

@@ -0,0 +1,57 @@
+import { ComputeShader } from "../ComputeShader";
+import { RenderShaderPass } from "../RenderShaderPass";
+import { ShaderPassBase } from "../ShaderPassBase";
+import { ShaderValue } from "./ShaderValue";
+export type ShaderReflectionAttribute = {
+    name: string;
+    group: number;
+    location: number;
+    type: string;
+    valueType: string;
+    value: number;
+    size: number;
+    format: GPUVertexFormat;
+};
+export type ShaderReflectionVarInfo = {
+    group: number;
+    binding: number;
+    varType: string;
+    varName: string;
+    dataType: string;
+    dataIsBuiltinType: boolean;
+    dataFields: ShaderReflectionStructInfo[];
+};
+export type ShaderReflectionStructInfo = {
+    name: string;
+    type: string;
+};
+export declare class ShaderReflection {
+    private static _shaderReflectionMap;
+    attributes: ShaderReflectionAttribute[];
+    vs_variables: ShaderReflectionVarInfo[];
+    fs_variables: ShaderReflectionVarInfo[];
+    cs_variables: ShaderReflectionVarInfo[];
+    groups: ShaderReflectionVarInfo[][];
+    variables: {
+        [name: string]: ShaderReflectionVarInfo;
+    };
+    useSplit: boolean;
+    static parser(wgsl: string, shaderValue: ShaderValue): void;
+    static parser2(wgsl: string, shaderBase: ShaderPassBase): void;
+    static combineShaderReflectionVarInfo(shaderReflection: ShaderReflection, shader_variables: ShaderReflectionVarInfo[]): void;
+    static final(shaderBase: ShaderPassBase): void;
+    static getShaderReflection2(code: string, shaderBase: ShaderPassBase): void;
+    static poolGetReflection(shaderVariant: string): ShaderReflection;
+    static genShaderVar(shaderValue: ShaderValue): string;
+    static genShaderVariant(shader: ShaderPassBase): string;
+    static genRenderShaderVariant(renderShader: RenderShaderPass): string;
+    static genComputeShaderVariant(computeShader: ComputeShader): string;
+    combine(shaderValue: ShaderValue): void;
+    private static parserVariables;
+    private static extract;
+    private static isBuiltinTypes;
+    private static parserStructFields;
+    private static parserVertexOld;
+    private static parserVertex;
+    private static parserAttribute;
+}

package/dist/types/gfx/graphics/webGpu/shader/value/ShaderState.d.ts

@@ -0,0 +1,30 @@
+import { BlendMode } from "../../../../../materials/BlendMode";
+export declare class ShaderState {
+    blendMode?: BlendMode;
+    depthCompare?: GPUCompareFunction;
+    depthWriteEnabled?: boolean;
+    frontFace?: GPUFrontFace;
+    cullMode?: GPUCullMode;
+    topology?: GPUPrimitiveTopology;
+    depthBias?: number;
+    useLight: boolean;
+    useProbe: boolean;
+    acceptGI: boolean;
+    acceptShadow: boolean;
+    castShadow: boolean;
+    castReflection: boolean;
+    receiveEnv: boolean;
+    renderLayer: number;
+    renderOrder: number;
+    unclippedDepth: boolean;
+    transparent: boolean;
+    multisample: number;
+    label: string;
+    useZ: boolean;
+    splitTexture: boolean;
+    alphaCutoff: number;
+    useFragDepth: boolean;
+    writeMasks: GPUColorWriteFlags[];
+    setFromMapValues(values: Map<string, any>): void;
+    protected convertBlendMode(value: string): BlendMode;
+}

package/dist/types/gfx/graphics/webGpu/shader/value/ShaderValue.d.ts

@@ -0,0 +1,32 @@
+import { UniformNode } from "../../core/uniforms/UniformNode";
+import { ConstValue } from "./ConstValue";
+import { ShaderReflection } from "./ShaderReflectionInfo";
+import { ShaderState } from "./ShaderState";
+export type ShaderUniform = {
+    [uniName: string]: UniformNode;
+};
+export type ShaderConst = {
+    [uniName: string]: ConstValue;
+};
+export type ShaderDefines = {
+    [uniName: string]: boolean | number | string;
+};
+export type ShaderValue = {
+    vs?: string;
+    fs?: string;
+    compute?: string;
+    vs_Source?: string;
+    fs_Source?: string;
+    compute_Source?: string;
+    vs_shader?: string;
+    fs_shader?: string;
+    vsModule?: GPUShaderModule;
+    fsModule?: GPUShaderModule;
+    csModule?: GPUShaderModule;
+    shaderVariant?: string;
+    uniforms?: ShaderUniform;
+    constValues?: ShaderConst;
+    defines?: ShaderDefines;
+    shaderState?: ShaderState;
+    shaderReflection?: ShaderReflection;
+};

package/dist/types/gfx/graphics/webGpu/shader/value/UniformValue.d.ts

@@ -0,0 +1,13 @@
+import { Color } from "../../../../../math/Color";
+import { Vector2 } from "../../../../../math/Vector2";
+import { Vector3 } from "../../../../../math/Vector3";
+import { Vector4 } from "../../../../../math/Vector4";
+export type UniformValue = number | Vector2 | Vector3 | Vector4 | Color | Float32Array | any;
+export declare enum UniformType {
+    Number = 0,
+    Vector2 = 1,
+    Vector3 = 2,
+    Vector4 = 3,
+    Color = 4,
+    Float32Array = 5
+}

package/dist/types/gfx/renderJob/GPUContext.d.ts

@@ -0,0 +1,32 @@
+import { Camera3D } from "../../core/Camera3D";
+import { GeometryBase } from "../../core/geometry/GeometryBase";
+import { Texture } from "../graphics/webGpu/core/texture/Texture";
+import { ComputeShader } from "../graphics/webGpu/shader/ComputeShader";
+import { RenderShaderPass } from "../graphics/webGpu/shader/RenderShaderPass";
+import { RendererPassState } from "./passRenderer/state/RendererPassState";
+export declare class GPUContext {
+    static lastGeometry: GeometryBase;
+    static lastPipeline: GPURenderPipeline | null;
+    static lastShader: RenderShaderPass;
+    static drawCount: number;
+    static renderPassCount: number;
+    static geometryCount: number;
+    static pipelineCount: number;
+    static matrixCount: number;
+    static lastRenderPassState: RendererPassState;
+    static LastCommand: GPUCommandEncoder | null;
+    static bindPipeline(encoder: GPURenderPassEncoder | GPURenderBundleEncoder, renderShader: RenderShaderPass): boolean;
+    static bindCamera(encoder: GPURenderPassEncoder | GPURenderBundleEncoder, camera: Camera3D): void;
+    static bindGeometryBuffer(encoder: GPURenderPassEncoder | GPURenderBundleEncoder, geometry: GeometryBase): void;
+    static cleanCache(): void;
+    static createPipeline(gpuRenderPipeline: GPURenderPipelineDescriptor): GPURenderPipeline;
+    static beginCommandEncoder(): GPUCommandEncoder | null;
+    static endCommandEncoder(command: GPUCommandEncoder): void;
+    static recordBundleEncoder(des: GPURenderBundleEncoderDescriptor): GPURenderBundleEncoder;
+    static beginRenderPass(command: GPUCommandEncoder, renderPassState: RendererPassState): GPURenderPassEncoder;
+    static drawIndexed(encoder: GPURenderPassEncoder, indexCount: GPUSize32, instanceCount?: GPUSize32, firstIndex?: GPUSize32, baseVertex?: GPUSignedOffset32, firstInstance?: GPUSize32): void;
+    static draw(encoder: GPURenderPassEncoder, vertexCount: GPUSize32, instanceCount?: GPUSize32, firstVertex?: GPUSize32, firstInstance?: GPUSize32): void;
+    static endPass(encoder: GPURenderPassEncoder): void;
+    static computeCommand(command: GPUCommandEncoder, computes: ComputeShader[]): void;
+    static copyTexture(command: GPUCommandEncoder, source: Texture, dest: Texture): void;
+}

package/dist/types/gfx/renderJob/collect/CollectInfo.d.ts

@@ -0,0 +1,7 @@
+import { RenderNode } from "../../../components/renderer/RenderNode";
+export declare class CollectInfo {
+    opaqueList: RenderNode[];
+    transparentList: RenderNode[];
+    sky: RenderNode;
+    clean(): void;
+}

package/dist/types/gfx/renderJob/collect/ComponentCollect.d.ts

@@ -0,0 +1,29 @@
+import { ColliderComponent } from "../../../components/ColliderComponent";
+import { IComponent } from "../../../components/IComponent";
+import { View3D } from "../../../core/View3D";
+import { Object3D } from "../../../core/entities/Object3D";
+export declare class ComponentCollect {
+    static componentsUpdateList: Map<View3D, Map<IComponent, Function>>;
+    static componentsLateUpdateList: Map<View3D, Map<IComponent, Function>>;
+    static componentsBeforeUpdateList: Map<View3D, Map<IComponent, Function>>;
+    static componentsComputeList: Map<View3D, Map<IComponent, Function>>;
+    static componentsEnablePickerList: Map<View3D, Map<ColliderComponent, Function>>;
+    static graphicComponent: Map<View3D, Map<IComponent, Function>>;
+    static waitStartComponent: Map<Object3D, IComponent[]>;
+    private static _init;
+    private static init;
+    static bindUpdate(view: View3D, component: IComponent, call: Function): void;
+    static unBindUpdate(view: View3D, component: IComponent): void;
+    static bindLateUpdate(view: View3D, component: IComponent, call: Function): void;
+    static unBindLateUpdate(view: View3D, component: IComponent): void;
+    static bindBeforeUpdate(view: View3D, component: IComponent, call: Function): void;
+    static unBindBeforeUpdate(view: View3D, component: IComponent): void;
+    static bindCompute(view: View3D, component: IComponent, call: Function): void;
+    static unBindCompute(view: View3D, component: IComponent): void;
+    static bindGraphic(view: View3D, component: IComponent, call: Function): void;
+    static unBindGraphic(view: View3D, component: IComponent): void;
+    static appendWaitStart(component: IComponent): void;
+    static removeWaitStart(obj: Object3D, component: IComponent): void;
+    static bindEnablePick(view: View3D, component: ColliderComponent, call: Function): void;
+    static unBindEnablePick(view: View3D, component: ColliderComponent): void;
+}

package/dist/types/gfx/renderJob/collect/EntityBatchCollect.d.ts

@@ -0,0 +1,7 @@
+import { RenderNode } from "../../../components/renderer/RenderNode";
+import { RenderGroup } from "./RenderGroup";
+export declare class EntityBatchCollect {
+    renderGroup: Map<string, RenderGroup>;
+    constructor();
+    collect_add(node: RenderNode): void;
+}