@rings-webgpu/core 1.0.6 → 1.0.7

package/dist/types/gfx/graphics/webGpu/core/texture/TextureCube.d.ts

@@ -0,0 +1,11 @@
+import { Texture } from "./Texture";
+export declare class TextureCube extends Texture {
+    width: number;
+    height: number;
+    depthOrArrayLayers: number;
+    visibility: number;
+    textureBindingLayout: GPUTextureBindingLayout;
+    samplerBindingLayout: GPUSamplerBindingLayout;
+    constructor();
+    protected createTextureDescriptor(width: number, height: number, mipLevelCount: number, format: GPUTextureFormat, usage?: number, sizeCount?: number): void;
+}

package/dist/types/gfx/graphics/webGpu/core/texture/TextureMipmapCompute.d.ts

@@ -0,0 +1,9 @@
+import { Texture } from "./Texture";
+export declare class TextureMipmapCompute {
+    private static codeMax;
+    private static codeMin;
+    private static _pipelineMax;
+    private static _pipelineMin;
+    static createMipmap(texture: Texture, mipmapCount: number): void;
+    private static mipmap;
+}

package/dist/types/gfx/graphics/webGpu/core/texture/TextureMipmapGenerator.d.ts

@@ -0,0 +1,9 @@
+import { Texture } from "./Texture";
+export declare class TextureMipmapGenerator {
+    private static mipmapShader;
+    private static pipelineCache;
+    private static pipeline;
+    static getMipmapPipeline(texture: Texture): GPURenderPipeline;
+    static webGPUGenerateMipmap(texture: Texture): void;
+    static getMipmapCount(width: number, height: number): number;
+}

package/dist/types/gfx/graphics/webGpu/core/uniforms/UniformNode.d.ts

@@ -0,0 +1,34 @@
+import { MemoryInfo } from "../../../../../core/pool/memory/MemoryInfo";
+import { Color } from "../../../../../math/Color";
+import { Vector2 } from "../../../../../math/Vector2";
+import { Vector3 } from "../../../../../math/Vector3";
+import { Vector4 } from "../../../../../math/Vector4";
+import { UniformValue } from "../../shader/value/UniformValue";
+export declare class UniformNode {
+    size: number;
+    memoryInfo: MemoryInfo;
+    bindOnChange: () => void;
+    private _data;
+    private _type;
+    private _x;
+    private _y;
+    private _z;
+    private _w;
+    constructor(value: UniformValue);
+    get data(): UniformValue;
+    set data(value: UniformValue);
+    getColor(ret: Color): Color;
+    get color(): Color;
+    set color(value: Color);
+    get value(): number;
+    set value(value: number);
+    get vector2(): Vector2;
+    set vector2(value: Vector2);
+    get vector3(): Vector3;
+    set vector3(value: Vector3);
+    get vector4(): Vector4;
+    set vector4(value: Vector4);
+    onChange(): void;
+    float32Array(value: Float32Array): void;
+    update(): void;
+}

package/dist/types/gfx/graphics/webGpu/descriptor/RTDescriptor.d.ts

@@ -0,0 +1,5 @@
+export declare class RTDescriptor {
+    storeOp: string;
+    loadOp: GPULoadOp;
+    clearValue: GPUColor;
+}

package/dist/types/gfx/graphics/webGpu/descriptor/WebGPUDescriptorCreator.d.ts

@@ -0,0 +1,8 @@
+import { RTFrame } from "../../../renderJob/frame/RTFrame";
+import { RendererPassState } from "../../../renderJob/passRenderer/state/RendererPassState";
+export declare class WebGPUDescriptorCreator {
+    private static rendererPassState;
+    static createRendererPassState(rtFrame: RTFrame, loadOp?: GPULoadOp): RendererPassState;
+    static getRenderPassDescriptor(renderPassState: RendererPassState, loadOp?: GPULoadOp): any;
+    static getRenderBundleDescriptor(renderPassState: RendererPassState): GPURenderBundleEncoderDescriptor;
+}

package/dist/types/gfx/graphics/webGpu/shader/ComputeShader.d.ts

@@ -0,0 +1,28 @@
+import { Texture } from "../core/texture/Texture";
+import { ShaderPassBase } from "./ShaderPassBase";
+import { ShaderReflectionVarInfo } from "./value/ShaderReflectionInfo";
+export declare class ComputeShader extends ShaderPassBase {
+    entryPoint: string;
+    workerSizeX: number;
+    workerSizeY: number;
+    workerSizeZ: number;
+    protected _computePipeline: GPUComputePipeline;
+    protected _csShaderModule: GPUShaderModule;
+    protected _destCS: string;
+    protected _sourceCS: string;
+    private _storageTextureDic;
+    private _sampleTextureDic;
+    private _groupsShaderReflectionVarInfos;
+    private _groupCache;
+    constructor(computeShader: string);
+    setStorageTexture(name: string, texture: Texture): void;
+    setSamplerTexture(name: string, texture: Texture): void;
+    compute(computePass: GPUComputePassEncoder): void;
+    private createBufferBindGroup;
+    protected noticeBufferChange(name: string): void;
+    protected genGroups(groupIndex: number, infos: ShaderReflectionVarInfo[][], force?: boolean): void;
+    protected genComputePipeline(): void;
+    protected preCompileShader(shader: string): void;
+    protected compileShader(): GPUShaderModule;
+    private genReflection;
+}

package/dist/types/gfx/graphics/webGpu/shader/RenderShaderPass.d.ts

@@ -0,0 +1,83 @@
+import { Color } from "../../../../math/Color";
+import { BlendMode } from "../../../../materials/BlendMode";
+import { GeometryBase } from "../../../../core/geometry/GeometryBase";
+import { GPUBufferBase } from "../core/buffer/GPUBufferBase";
+import { Texture } from "../core/texture/Texture";
+import { ShaderPassBase } from "./ShaderPassBase";
+import { ShaderStage } from "./ShaderStage";
+import { ShaderReflectionVarInfo } from "./value/ShaderReflectionInfo";
+import { ShaderState } from "./value/ShaderState";
+import { RendererPassState } from "../../../renderJob/passRenderer/state/RendererPassState";
+import { UniformValue } from "./value/UniformValue";
+import { PassType } from "../../../renderJob/passRenderer/state/PassType";
+import { Vector4 } from "../../../../math/Vector4";
+export declare class RenderShaderPass extends ShaderPassBase {
+    passType: PassType;
+    useRz: boolean;
+    vsName: string;
+    fsName: string;
+    shaderState: ShaderState;
+    textures: {
+        [name: string]: Texture;
+    };
+    pipeline: GPURenderPipeline;
+    bindGroupLayouts: GPUBindGroupLayout[];
+    envMap: Texture;
+    prefilterMap: Texture;
+    reflectionMap: Texture;
+    protected _sourceVS: string;
+    protected _sourceFS: string;
+    protected _destVS: string;
+    protected _destFS: string;
+    protected _vsShaderModule: GPUShaderModule;
+    protected _fsShaderModule: GPUShaderModule;
+    protected _textureGroup: number;
+    protected _textureChange: boolean;
+    protected _groupsShaderReflectionVarInfos: ShaderReflectionVarInfo[][];
+    outBufferMask: Vector4;
+    constructor(vs: string, fs: string);
+    get renderOrder(): number;
+    set renderOrder(value: number);
+    get doubleSide(): boolean;
+    set doubleSide(value: boolean);
+    get depthWriteEnabled(): boolean;
+    set depthWriteEnabled(value: boolean);
+    get cullMode(): GPUCullMode;
+    set cullMode(value: GPUCullMode);
+    get frontFace(): GPUFrontFace;
+    set frontFace(value: GPUFrontFace);
+    get depthBias(): number;
+    set depthBias(value: number);
+    get topology(): GPUPrimitiveTopology;
+    set topology(value: GPUPrimitiveTopology);
+    get blendMode(): BlendMode;
+    set blendMode(value: BlendMode);
+    get depthCompare(): GPUCompareFunction;
+    set depthCompare(value: GPUCompareFunction);
+    setShaderEntry(vsEntryPoint?: string, fsEntryPoint?: string): void;
+    setUniform(name: string, value: UniformValue): void;
+    setTexture(name: string, texture: Texture): void;
+    get baseColor(): Color;
+    set baseColor(value: Color);
+    getTexture(name: string): Texture;
+    genRenderPipeline(geometry: GeometryBase, renderPassState: RendererPassState): void;
+    reBuild(geometry: GeometryBase, rendererPassState: RendererPassState): void;
+    apply(geometry: GeometryBase, rendererPassState: RendererPassState, noticeFun?: Function): void;
+    preCompile(geometry: GeometryBase): void;
+    applyPostDefine(shader: string, renderPassState: RendererPassState): string;
+    setBindGroup(groupIndex: number, group: GPUBindGroup): void;
+    protected checkBuffer(bufferName: string, buffer: GPUBufferBase): void;
+    protected preCompileShader(stage: ShaderStage, code: string, format?: string): void;
+    protected compileShader(stage: ShaderStage, code: string, renderPassState: RendererPassState): void;
+    protected getGroupLayout(index: number, infos: ShaderReflectionVarInfo[]): GPUBindGroupLayoutEntry[];
+    private _cacheEntries;
+    protected genGroups(groupIndex: number, infos: ShaderReflectionVarInfo[][], force?: boolean): void;
+    private createPipeline;
+    private createGroupLayouts;
+    private preDefine;
+    private genReflection;
+    destroy(force?: boolean): void;
+    static destroyShader(instanceID: string): void;
+    static getShader(instanceID: string): RenderShaderPass;
+    static createShader(vs: string, fs: string): string;
+}

package/dist/types/gfx/graphics/webGpu/shader/Shader.d.ts

@@ -0,0 +1,53 @@
+import { RenderShaderCompute } from "../compute/RenderShaderCompute";
+import { GPUBufferBase } from "../core/buffer/GPUBufferBase";
+import { StorageGPUBuffer } from "../core/buffer/StorageGPUBuffer";
+import { StructStorageGPUBuffer } from "../core/buffer/StructStorageGPUBuffer";
+import { UniformGPUBuffer } from "../core/buffer/UniformGPUBuffer";
+import { Texture } from "../core/texture/Texture";
+import { RenderShaderPass } from "./RenderShaderPass";
+import { UniformValue } from "./value/UniformValue";
+import { PassType } from "../../../renderJob/passRenderer/state/PassType";
+import { Color } from "../../../../math/Color";
+import { Vector2 } from "../../../../math/Vector2";
+import { Vector3 } from "../../../../math/Vector3";
+import { Vector4 } from "../../../../math/Vector4";
+import { Struct } from "../../../../util/struct/Struct";
+export declare class Shader {
+    computes: RenderShaderCompute[];
+    passShader: Map<PassType, RenderShaderPass[]>;
+    constructor();
+    addRenderPass(renderShader: RenderShaderPass, index?: number): void;
+    removeShader(renderShader: RenderShaderPass, index?: number): void;
+    removeShaderByIndex(passType: PassType, index?: number): void;
+    getSubShaders(passType: PassType): RenderShaderPass[];
+    hasSubShaders(passType: PassType): boolean;
+    getDefaultShaders(): RenderShaderPass[];
+    getDefaultColorShader(): RenderShaderPass;
+    setDefine(arg0: string, arg1: boolean): void;
+    hasDefine(arg0: string): boolean;
+    deleteDefine(arg0: string): void;
+    setUniform(arg0: string, arg1: UniformValue): void;
+    setUniformFloat(arg0: string, arg1: number): void;
+    setUniformVector2(arg0: string, arg1: Vector2): void;
+    setUniformVector3(arg0: string, arg1: Vector3): void;
+    setUniformVector4(arg0: string, arg1: Vector4): void;
+    setUniformColor(arg0: string, arg1: Color): void;
+    getUniform(arg0: string): any;
+    getUniformFloat(arg0: string): number;
+    getUniformVector2(arg0: string): Vector2;
+    getUniformVector3(arg0: string): Vector3;
+    getUniformVector4(arg0: string): Vector4;
+    getUniformColor(arg0: string): Color;
+    setTexture(arg0: string, arg1: Texture): void;
+    getTexture(arg0: string): Texture;
+    setUniformBuffer(arg0: string, arg1: UniformGPUBuffer): void;
+    getUniformBuffer(arg0: string): GPUBufferBase;
+    setStorageBuffer(arg0: string, arg1: StorageGPUBuffer): void;
+    getStorageBuffer(arg0: string): StorageGPUBuffer;
+    setStructStorageBuffer<T extends Struct>(arg0: string, arg1: StructStorageGPUBuffer<T>): void;
+    getStructStorageBuffer(arg0: string): GPUBufferBase;
+    noticeValueChange(): void;
+    destroy(): void;
+    clone(): Shader;
+    applyUniform(): void;
+}

package/dist/types/gfx/graphics/webGpu/shader/ShaderPassBase.d.ts

@@ -0,0 +1,60 @@
+import { GPUBufferBase } from "../core/buffer/GPUBufferBase";
+import { Color } from "../../../../math/Color";
+import { Vector2 } from "../../../../math/Vector2";
+import { Vector3 } from "../../../../math/Vector3";
+import { Vector4 } from "../../../../math/Vector4";
+import { Struct } from "../../../../util/struct/Struct";
+import { StorageGPUBuffer } from "../core/buffer/StorageGPUBuffer";
+import { StructStorageGPUBuffer } from "../core/buffer/StructStorageGPUBuffer";
+import { UniformGPUBuffer } from "../core/buffer/UniformGPUBuffer";
+import { UniformNode } from "../core/uniforms/UniformNode";
+import { ShaderReflection } from "./value/ShaderReflectionInfo";
+import { UniformValue } from "./value/UniformValue";
+import { MaterialDataUniformGPUBuffer } from "../core/buffer/MaterialDataUniformGPUBuffer";
+export declare class ShaderPassBase {
+    readonly instanceID: string;
+    shaderVariant: string;
+    vsEntryPoint: string;
+    fsEntryPoint: string;
+    bindGroups: GPUBindGroup[];
+    shaderReflection: ShaderReflection;
+    defineValue: {
+        [name: string]: any;
+    };
+    constValues: {
+        [name: string]: any;
+    };
+    uniforms: {
+        [name: string]: UniformNode;
+    };
+    materialDataUniformBuffer: MaterialDataUniformGPUBuffer;
+    protected _bufferDic: Map<string, GPUBufferBase>;
+    protected _shaderChange: boolean;
+    protected _valueChange: boolean;
+    constructor();
+    noticeShaderChange(): void;
+    noticeValueChange(): void;
+    setStorageBuffer(name: string, buffer: StorageGPUBuffer): void;
+    setStructStorageBuffer<T extends Struct>(name: string, buffer: StructStorageGPUBuffer<T>): void;
+    setUniformBuffer(name: string, buffer: UniformGPUBuffer): void;
+    setDefine(defineName: string, value: any): void;
+    hasDefine(defineName: string): boolean;
+    deleteDefine(defineName: string): void;
+    setUniformFloat(name: string, value: number): void;
+    setUniformVector2(name: string, value: Vector2): void;
+    setUniformVector3(name: string, value: Vector3): void;
+    setUniformVector4(name: string, value: Vector4): void;
+    setUniformColor(name: string, value: Color): void;
+    setUniformArray(name: string, value: Float32Array): void;
+    setUniform(name: string, value: UniformValue): void;
+    getUniform(name: string): UniformValue;
+    getUniformFloat(name: string): number;
+    getUniformVector2(name: string): Vector2;
+    getUniformVector3(name: string): Vector3;
+    getUniformVector4(name: string): Vector4;
+    getUniformColor(name: string): Color;
+    getBuffer(name: string): GPUBufferBase;
+    protected noticeBufferChange(name: string): void;
+    applyUniform(): void;
+    destroy(force?: boolean): void;
+}

package/dist/types/gfx/graphics/webGpu/shader/ShaderStage.d.ts

@@ -0,0 +1,5 @@
+export declare enum ShaderStage {
+    vertex = 0,
+    fragment = 1,
+    computer = 2
+}

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

@@ -0,0 +1,16 @@
+import { GLSLLexerToken } from "./GLSLLexerToken";
+import { GLSLPreprocessor } from "./GLSLPreprocessor";
+import { Reader } from "./Reader";
+export declare class GLSLLexer extends Reader {
+    private _tokenPosition;
+    private _tokens;
+    constructor(input: GLSLPreprocessor);
+    skipToken(offset: number): void;
+    peekToken(offset: number): GLSLLexerToken;
+    GetNextToken(): GLSLLexerToken;
+    get currTokenPosition(): number;
+    private parse;
+    private nextToken;
+    private readDecimal;
+    private lookupIdentifier;
+}

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

@@ -0,0 +1,174 @@
+export declare class GLSLLexerToken {
+    Type: TokenType;
+    Line: number;
+    Colume: number;
+    Literal: string;
+    constructor(type?: TokenType, literal?: string);
+    /**
+     * @returns determin the type is same to token
+     */
+    isTypeEqual(type: TokenType): boolean;
+    /**
+     * @returns determin the value is same
+     */
+    isLiteralEqual(literal: string): boolean;
+    /**
+     * @returns determin it's builtin type
+     */
+    isBuiltinType(): boolean;
+    /**
+     * @returns determin it's a data type
+     */
+    isDataType(): boolean;
+    /**
+     * @returns determin it's a operation
+     */
+    isOperation(): boolean;
+    /**
+     * @returns determin it's a assign operation
+     */
+    isAssignOperation(): boolean;
+    /**
+     * The priority of the current operator
+     */
+    get nOperationPriorityLevel(): number;
+}
+/**
+ * @internal
+ */
+export declare enum TokenType {
+    EOF = 0,
+    IDENT = 1,
+    VOID = 2,
+    CONST = 3,
+    LAYOUT = 4,
+    PRECISION = 5,
+    ATTRIBUTE = 6,
+    UNIFORM = 7,
+    VARYING = 8,
+    INVARIANT = 9,
+    IN = 10,
+    OUT = 11,
+    INOUT = 12,
+    IF = 13,
+    ELSE = 14,
+    FOR = 15,
+    WHILE = 16,
+    DO = 17,
+    BREAK = 18,
+    RETURN = 19,
+    CONTINUE = 20,
+    STRUCT = 21,
+    COMMA = 22,
+    COLON = 23,
+    QUEMARK = 24,
+    SEMICOLON = 25,
+    LEFTSAMLL = 26,
+    RIGHTSAMLL = 27,
+    LEFTMEDI = 28,
+    RIGHTMEDI = 29,
+    LEFTBIG = 30,
+    RIGHTBIG = 31,
+    LITERAL = 32,
+    BeginBuiltinType = 33,
+    INT = 34,
+    INT_ARRAY = 35,
+    UINT = 36,
+    UINT_ARRAY = 37,
+    BOOL = 38,
+    BOOL_ARRAY = 39,
+    FLOAT = 40,
+    FLOAT_ARRAY = 41,
+    DOUBLE = 42,
+    DOUBLE_ARRAY = 43,
+    VEC2 = 44,
+    VEC2_ARRAY = 45,
+    VEC3 = 46,
+    VEC3_ARRAY = 47,
+    VEC4 = 48,
+    VEC4_ARRAY = 49,
+    BVEC2 = 50,
+    BVEC2_ARRAY = 51,
+    BVEC3 = 52,
+    BVEC3_ARRAY = 53,
+    BVEC4 = 54,
+    BVEC4_ARRAY = 55,
+    IVEC2 = 56,
+    IVEC2_ARRAY = 57,
+    IVEC3 = 58,
+    IVEC3_ARRAY = 59,
+    IVEC4 = 60,
+    IVEC4_ARRAY = 61,
+    UVEC2 = 62,
+    UVEC2_ARRAY = 63,
+    UVEC3 = 64,
+    UVEC3_ARRAY = 65,
+    UVEC4 = 66,
+    UVEC4_ARRAY = 67,
+    MAT2x2 = 68,
+    MAT2x2_ARRAY = 69,
+    MAT2x3 = 70,
+    MAT2x3_ARRAY = 71,
+    MAT2x4 = 72,
+    MAT2x4_ARRAY = 73,
+    MAT3x2 = 74,
+    MAT3x2_ARRAY = 75,
+    MAT3x3 = 76,
+    MAT3x3_ARRAY = 77,
+    MAT3x4 = 78,
+    MAT3x4_ARRAY = 79,
+    MAT4x2 = 80,
+    MAT4x2_ARRAY = 81,
+    MAT4x3 = 82,
+    MAT4x3_ARRAY = 83,
+    MAT4x4 = 84,
+    MAT4x4_ARRAY = 85,
+    SAMPLER = 86,
+    SAMPLER_1D = 87,
+    SAMPLER_2D = 88,
+    SAMPLER_3D = 89,
+    SAMPLER_CUBE = 90,
+    SAMPLER_SHADOW = 91,
+    SAMPLER_1D_SHADOW = 92,
+    SAMPLER_2D_SHADOW = 93,
+    TEXTURE_1D = 94,
+    TEXTURE_1D_ARRAY = 95,
+    TEXTURE_2D = 96,
+    TEXTURE_2D_ARRAY = 97,
+    TEXTURE_3D = 98,
+    TEXTURE_CUBE = 99,
+    TEXTURE_CUBE_ARRAY = 100,
+    EndBuiltinType = 101,
+    BeginOperation = 102,
+    ADD = 103,
+    SUB = 104,
+    MUL = 105,
+    DIV = 106,
+    AND = 107,
+    OR = 108,
+    XOR = 109,
+    NOT = 110,
+    BITAND = 111,
+    BITOR = 112,
+    BITXOR = 113,
+    BITNOT = 114,
+    BITSHIFT_L = 115,
+    BITSHIFT_R = 116,
+    INC = 117,
+    DEC = 118,
+    GREATER = 119,
+    GREATEREQUAL = 120,
+    EQUAL = 121,
+    LESS = 122,
+    LESSEQUAL = 123,
+    NOTEQUAL = 124,
+    DOT = 125,
+    ASSIGN = 126,
+    EndOperation = 127,
+    BeginAssignOperation = 128,
+    ADDASSIGN = 129,
+    SUBASSIGN = 130,
+    MULASSIGN = 131,
+    DIVASSIGN = 132,
+    EndAssignOperation = 133
+}

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

@@ -0,0 +1,10 @@
+import { Reader } from "./Reader";
+export declare class GLSLPreprocessor extends Reader {
+    private _result;
+    private _skipLine;
+    private _definitionTables;
+    constructor(source: string);
+    private parse;
+    get source(): string;
+    private parseArgs;
+}

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

@@ -0,0 +1,14 @@
+import { GLSLLexer } from "./GLSLLexer";
+import { StatementNode } from "./StatementNode";
+export declare class GLSLSyntax {
+    private _lexer;
+    private _rootNode;
+    constructor(input: GLSLLexer);
+    get lexer(): GLSLLexer;
+    private parse;
+    private parseStatement;
+    private skipToken;
+    private peekToken;
+    private getNextToken;
+    get ASTRoot(): StatementNode;
+}

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

@@ -0,0 +1,30 @@
+/**
+ * @internal
+ * @group GFX
+ */
+export declare class Reader {
+    protected _char: string;
+    protected _line: number;
+    protected _column: number;
+    protected _source: string;
+    protected _currPosition: number;
+    protected _nextPosition: number;
+    constructor(source: string);
+    reset(source: string): void;
+    get source(): string;
+    getChar(): string;
+    get currPosition(): number;
+    peekChar(): string;
+    readChar(): void;
+    readCharAndSkipWhitespace(): void;
+    readIdentifier(): string;
+    isIdentifier(char: string): boolean;
+    skipWhitespace(): void;
+    IsWhitespace(char: string): boolean;
+    skipComment(): void;
+    skipMultilineComment(): void;
+    isDigit(char: string): boolean;
+    readNumber(): string;
+    readValue(): string;
+    readLine(): string;
+}

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

@@ -0,0 +1,47 @@
+export declare class ShaderConverter {
+    /**
+     * Shader type: Vertex stage
+     */
+    static VertexShader: string;
+    /**
+     * Shader type: Fragment stage
+     */
+    static FragmentShader: string;
+    /**
+     * Convert GLSL code to WGSL
+     * @param source GLSL
+     * @returns WGSL
+     */
+    static convertGLSL(source: string): ShaderConverterResult;
+}
+/**
+ * @internal
+ * @group GFX
+ */
+export declare class ShaderUniformInfo {
+    setID: number;
+    bindingID: number;
+    name: string;
+    type: string;
+}
+/**
+ * @internal
+ * @group GFX
+ */
+export declare class ShaderAttributeInfo {
+    name: string;
+    type: string;
+    locationID: number;
+    builtinName: string;
+    isBuiltinAttribute(): boolean;
+}
+/**
+ * @internal
+ * @group GFX
+ */
+export declare class ShaderConverterResult {
+    uniformInfo: Array<ShaderUniformInfo>;
+    inputAttribute: Array<ShaderAttributeInfo>;
+    outputAttribute: Array<ShaderAttributeInfo>;
+    sourceCode: string;
+}