@rings-webgpu/core 1.0.2 → 1.0.4

package/dist/src/gfx/graphics/webGpu/shader/value/ShaderReflectionInfo.js

@@ -1,421 +0,0 @@
-import { VertexAttributeSize } from "../../../../../core/geometry/VertexAttributeSize";
-import { VertexFormat } from "../../../../../core/geometry/VertexFormat";
-import { Preprocessor } from "../util/Preprocessor";
-export class ShaderReflection {
-    constructor() {
-        this.attributes = [];
-        this.vs_variables = [];
-        this.fs_variables = [];
-        this.cs_variables = [];
-        this.groups = [];
-        this.variables = {};
-        this.useSplit = false;
-    }
-    static { this._shaderReflectionMap = new Map(); }
-    static parser(wgsl, shaderValue) {
-        if (!shaderValue.shaderReflection)
-            shaderValue.shaderReflection = new ShaderReflection();
-        if (wgsl.indexOf(`@vertex`) != -1) {
-            shaderValue.shaderReflection.attributes = this.parserVertexOld(wgsl);
-            shaderValue.shaderReflection.vs_variables = this.parserVariables(wgsl);
-        }
-        else if (wgsl.indexOf(`@fragment`) != -1) {
-            shaderValue.shaderReflection.fs_variables = this.parserVariables(wgsl);
-        }
-        else if (wgsl.indexOf(`@compute`) != -1) {
-            shaderValue.shaderReflection.cs_variables = this.parserVariables(wgsl);
-        }
-    }
-    static parser2(wgsl, shaderBase) {
-        if (!shaderBase.shaderReflection)
-            shaderBase.shaderReflection = new ShaderReflection();
-        let shaderReflection = shaderBase.shaderReflection;
-        if (wgsl.indexOf(`@vertex`) != -1) {
-            shaderReflection.attributes = this.parserVertex(shaderBase.vsEntryPoint, wgsl);
-            shaderReflection.vs_variables = this.parserVariables(wgsl);
-        }
-        else if (wgsl.indexOf(`@fragment`) != -1) {
-            shaderReflection.fs_variables = this.parserVariables(wgsl);
-        }
-        else if (wgsl.indexOf(`@compute`) != -1) {
-            shaderReflection.cs_variables = this.parserVariables(wgsl);
-        }
-        if (wgsl.indexOf("splitTexture") != -1) {
-            shaderReflection.useSplit = true;
-        }
-    }
-    static combineShaderReflectionVarInfo(shaderReflection, shader_variables) {
-        for (const iterator of shader_variables) {
-            if (!shaderReflection.groups[iterator.group]) {
-                shaderReflection.groups[iterator.group] = [];
-            }
-            let combineInfo = iterator;
-            if (shaderReflection.groups[iterator.group][iterator.binding]) {
-                let aInfo = shaderReflection.groups[iterator.group][iterator.binding];
-                let bInfo = iterator;
-                if (import.meta.env.DEV) {
-                    if (aInfo.varName != bInfo.varName)
-                        console.warn(`shader reflection var not match! var name vs : ${aInfo.varName} , fs : ${bInfo.varName}`);
-                    if (aInfo.varType != bInfo.varType)
-                        console.error(`shader reflection varType not match! var varType vs : ${aInfo.varType} , fs : ${bInfo.varType}`);
-                    if (aInfo.dataType != bInfo.dataType)
-                        console.warn(`shader reflection dataType not match! var dataType vs : ${aInfo.dataType} , fs : ${bInfo.dataType}`);
-                    if (aInfo.dataIsBuiltinType != bInfo.dataIsBuiltinType)
-                        console.error(`shader reflection dataIsBuiltinType not match! var dataIsBuiltinType vs : ${aInfo.dataIsBuiltinType} , fs : ${bInfo.dataType}`);
-                    if (!aInfo.dataFields || !bInfo.dataFields) {
-                        console.warn(`shader reflection dataFields is empty! var dataFields vs : ${aInfo.dataFields} , fs : ${bInfo.dataFields}`);
-                    }
-                }
-                let fileds = [];
-                if (aInfo.dataFields) {
-                    for (let i = 0; i < aInfo.dataFields.length; i++) {
-                        const element = aInfo.dataFields[i];
-                        fileds[i] = element;
-                    }
-                }
-                if (bInfo.dataFields) {
-                    for (let i = 0; i < bInfo.dataFields.length; i++) {
-                        const element = bInfo.dataFields[i];
-                        fileds[i] = element;
-                    }
-                }
-            }
-            shaderReflection.groups[iterator.group][iterator.binding] = combineInfo;
-            shaderReflection.variables[iterator.varName] = combineInfo;
-        }
-    }
-    static final(shaderBase) {
-        let shaderReflection = shaderBase.shaderReflection;
-        this._shaderReflectionMap.set(shaderBase.shaderVariant, shaderReflection);
-        this.combineShaderReflectionVarInfo(shaderReflection, shaderReflection.vs_variables);
-        this.combineShaderReflectionVarInfo(shaderReflection, shaderReflection.fs_variables);
-    }
-    static getShaderReflection2(code, shaderBase) {
-        let preShader = Preprocessor.parse(code, shaderBase.defineValue);
-        ShaderReflection.parser2(preShader, shaderBase);
-    }
-    static poolGetReflection(shaderVariant) {
-        let ref = this._shaderReflectionMap.get(shaderVariant);
-        return ref;
-    }
-    static genShaderVar(shaderValue) {
-        let shaderVariant = `${shaderValue.vs}${shaderValue.fs}${shaderValue.compute}`;
-        shaderVariant += "|";
-        for (const key in shaderValue.uniforms) {
-            shaderVariant += key + ":";
-        }
-        shaderVariant += "|";
-        for (const key in shaderValue.constValues) {
-            shaderVariant += key + ":";
-            shaderVariant += shaderValue.constValues[key];
-        }
-        shaderVariant += "|";
-        for (const key in shaderValue.defines) {
-            shaderVariant += key + ":";
-            shaderVariant += shaderValue.defines[key];
-        }
-        shaderVariant += "|";
-        for (const key in shaderValue.shaderState) {
-            shaderVariant += key + ":";
-            shaderVariant += shaderValue.shaderState[key] + ";";
-        }
-        return shaderVariant;
-    }
-    static genShaderVariant(shader) {
-        let shaderVariant = "";
-        for (const key in shader.uniforms) {
-            shaderVariant += key + ":";
-        }
-        shaderVariant += "|";
-        for (const key in shader.constValues) {
-            shaderVariant += key + ":";
-            shaderVariant += shader.constValues[key];
-        }
-        shaderVariant += "|";
-        for (const key in shader.defineValue) {
-            shaderVariant += key + ":";
-            shaderVariant += shader.defineValue[key];
-        }
-        return shaderVariant;
-    }
-    static genRenderShaderVariant(renderShader) {
-        let shaderVariant = `RenderShader(${renderShader.vsName},${renderShader.fsName})`;
-        shaderVariant += "|";
-        shaderVariant += this.genShaderVariant(renderShader);
-        shaderVariant += "|";
-        for (const key in renderShader.shaderState) {
-            shaderVariant += key + ":";
-            shaderVariant += renderShader.shaderState[key] + ";";
-        }
-        return shaderVariant;
-    }
-    static genComputeShaderVariant(computeShader) {
-        let shaderVariant = `ComputeShader(${computeShader.instanceID})`;
-        shaderVariant += "|";
-        shaderVariant += this.genShaderVariant(computeShader);
-        return shaderVariant;
-    }
-    combine(shaderValue) {
-        let shaderReflection = shaderValue.shaderReflection;
-        let defines = shaderValue.defines;
-        let tmp = {};
-        for (let i = 0; i < this.attributes.length; i++) {
-            let att = this.attributes[i];
-            if (defines[att.name])
-                tmp[att.name] = att;
-        }
-        let len = shaderReflection.attributes.length;
-        for (let j = 0; j < len; j++) {
-            const newAtt = shaderReflection.attributes[j];
-            if (!tmp[newAtt.name]) {
-                this.attributes.push(newAtt);
-            }
-            else {
-                let oldAtt = tmp[newAtt.name];
-                if (oldAtt.location == newAtt.location && oldAtt.name != newAtt.name) {
-                    console.log("location must same!");
-                }
-            }
-        }
-    }
-    static parserVariables(wgsl) {
-        let position = 0;
-        let variables = [];
-        while (position < wgsl.length) {
-            let nLeftIndex = wgsl.indexOf("@group(", position);
-            if (nLeftIndex < 0)
-                break;
-            let nRightIndex = wgsl.indexOf(";", nLeftIndex);
-            position = nRightIndex;
-            let item = wgsl.substring(nLeftIndex, nRightIndex);
-            let group = this.extract(item, "@group(", ")");
-            let binding = this.extract(item, "@binding(", ")");
-            let varName = "";
-            let varType = "var";
-            if (item.indexOf("var<") != -1) {
-                varName = this.extract(item, ">", ":");
-                varType = this.extract(item, "var<", ">")
-                    .replace(",", "-")
-                    .replaceAll(" ", "");
-            }
-            else {
-                varName = this.extract(item, "var", ":");
-            }
-            let dataType = item.substring(item.lastIndexOf(":") + 1).trim();
-            let info = {
-                group: 0,
-                binding: 0,
-                varType: "",
-                varName: "",
-                dataType: "",
-                dataIsBuiltinType: true,
-                dataFields: null,
-            };
-            info.group = Number.parseInt(group);
-            info.binding = Number.parseInt(binding);
-            info.varType = varType;
-            info.varName = varName;
-            info.dataType = dataType;
-            info.dataIsBuiltinType = this.isBuiltinTypes(info.dataType);
-            if (!info.dataIsBuiltinType) {
-                info.dataFields = this.parserStructFields(wgsl, info.dataType);
-            }
-            variables.push(info);
-        }
-        return variables;
-    }
-    static extract(str, leftStr, rightStr) {
-        let indexL = str.indexOf(leftStr) + leftStr.length;
-        let indexR = str.indexOf(rightStr, indexL);
-        return str.substring(indexL, indexR).trim();
-    }
-    static isBuiltinTypes(dataType) {
-        switch (dataType) {
-            case "i32":
-                return true;
-            case "u32":
-                return true;
-            case "f32":
-                return true;
-            default:
-                let index = dataType.indexOf("<");
-                if (index != -1) {
-                    let type = dataType.substring(0, index);
-                    switch (type) {
-                        case "vec2":
-                            return true;
-                        case "vec3":
-                            return true;
-                        case "vec4":
-                            return true;
-                        case "mat3":
-                            return true;
-                        case "mat4":
-                            return true;
-                        case "array":
-                            return this.isBuiltinTypes(dataType.substring(index + 1, dataType.lastIndexOf(">")));
-                    }
-                }
-                break;
-        }
-        return false;
-    }
-    static parserStructFields(wgsl, structName) {
-        let result = [];
-        let position = 0;
-        let variables = [];
-        while (position < wgsl.length) {
-            let nLeftIndex = wgsl.indexOf("struct ", position);
-            if (nLeftIndex < 0)
-                break;
-            let nRightIndex = wgsl.indexOf("{", nLeftIndex);
-            position = nRightIndex;
-            let name = wgsl.substring(nLeftIndex + 6, nRightIndex).trim();
-            if (name === structName) {
-                nLeftIndex = wgsl.indexOf("{", nLeftIndex);
-                nRightIndex = wgsl.indexOf("}", nLeftIndex);
-                let items = wgsl.substring(nLeftIndex + 1, nRightIndex);
-                let fields = items.split(",");
-                for (let field of fields) {
-                    let index = field.indexOf(":");
-                    if (index != -1) {
-                        let obj = {
-                            name: field.substring(0, index).trim(),
-                            type: field.substring(index + 1).trim(),
-                        };
-                        result.push(obj);
-                    }
-                }
-                break;
-            }
-        }
-        return result;
-    }
-    static parserVertexOld(wgsl) {
-        let attributes = [];
-        let list = wgsl.split(`fn main(`);
-        let block = list[1].split("->")[0];
-        let blockList = block.split("@");
-        if (blockList && blockList.length > 1) {
-            for (let i = 1; i < blockList.length; i++) {
-                const element = blockList[i];
-                let code = element.replace(/\s*$/g, "");
-                code = code.replaceAll(",", "");
-                code = code.replaceAll("\n", "");
-                code = code.replaceAll("  ", " ");
-                this.parserAttribute(code, attributes);
-            }
-        }
-        else {
-            let code1 = block.split(":");
-            var code = code1[1];
-            code = code.replaceAll("  ", "");
-            code = code.replaceAll(" ", "");
-            code = code.replaceAll(")", "");
-            code = wgsl.split(`struct ${code}`)[1];
-            let start = code.indexOf("{");
-            let end = code.indexOf("}");
-            code = code.slice(start, end);
-            blockList = code.split("@");
-            for (let i = 1; i < blockList.length; i++) {
-                const element = blockList[i];
-                let code = element.replace(/\s*$/g, "");
-                code = code.replaceAll("\n", "");
-                code = code.split(",")[0];
-                code = code.replaceAll("  ", " ");
-                this.parserAttribute(code, attributes);
-            }
-        }
-        return attributes;
-    }
-    static parserVertex(entryPoint, wgsl) {
-        let attributes = [];
-        let list = wgsl.split(`fn ${entryPoint}(`);
-        let block = list[1].split('->')[0];
-        let blockList = block.split("@");
-        if (blockList && blockList.length > 1) {
-            for (let i = 1; i < blockList.length; i++) {
-                const element = blockList[i];
-                let code = element.replace(/\s*$/g, "");
-                code = code.replaceAll(",", "");
-                code = code.replaceAll("\n", "");
-                code = code.replaceAll("  ", " ");
-                this.parserAttribute(code, attributes);
-            }
-        }
-        else {
-            let code1 = block.split(":");
-            var code = code1[1];
-            code = code.replaceAll("  ", "");
-            code = code.replaceAll(" ", "");
-            code = code.replaceAll(")", "");
-            code = wgsl.split(`struct ${code}`)[1];
-            let start = code.indexOf("{");
-            let end = code.indexOf("}");
-            code = code.slice(start, end);
-            blockList = code.split("@");
-            for (let i = 1; i < blockList.length; i++) {
-                const element = blockList[i];
-                let code = element.replace(/\s*$/g, "");
-                code = code.replaceAll("\n", "");
-                code = code.split(",")[0];
-                code = code.replaceAll("  ", " ");
-                this.parserAttribute(code, attributes);
-            }
-        }
-        return attributes;
-    }
-    static parserAttribute(line, attributes) {
-        let obj = {
-            name: "",
-            group: 0,
-            location: 0,
-            type: "",
-            valueType: "",
-            value: 0,
-            size: 0,
-            format: `float32`,
-        };
-        if (line.indexOf("builtin") != -1) {
-            obj.type = "builtin";
-            var tmp = line.match(/\((.+?)\)/g)[0];
-            tmp = line.match(/\((.+?)\)/g)[0];
-            tmp = tmp.replace("(", "");
-            tmp = tmp.replaceAll(")", "");
-            obj.location = parseInt(tmp);
-            let cc = line.split(":");
-            obj.name = cc[0].split(" ")[1];
-            obj.name = obj.name.replaceAll("  ", " ");
-            obj.name = obj.name.replaceAll(" ", "");
-            obj.valueType = cc[1];
-            obj.valueType = obj.valueType.replaceAll("  ", " ");
-            obj.valueType = obj.valueType.replaceAll(" ", "");
-            obj.valueType = obj.valueType.replaceAll("\r", "");
-            obj.valueType = obj.valueType.replaceAll(")", "");
-            obj.valueType = obj.valueType.replaceAll(")", "");
-            obj.size = VertexAttributeSize[obj.valueType];
-            attributes.push(obj);
-        }
-        else if (line.indexOf("location") != -1) {
-            obj.type = "location";
-            var tmp = line.match(/\((.+?)\)/g)[0];
-            tmp = line.match(/\((.+?)\)/g)[0];
-            tmp = tmp.replace("(", "");
-            tmp = tmp.replaceAll(")", "");
-            obj.location = parseInt(tmp);
-            let cc = line.split(":");
-            obj.name = cc[0].split(" ")[1];
-            obj.name = obj.name.replaceAll("  ", " ");
-            obj.name = obj.name.replaceAll(" ", "");
-            obj.valueType = cc[1];
-            obj.valueType = obj.valueType.replaceAll("  ", " ");
-            obj.valueType = obj.valueType.replaceAll(" ", "");
-            obj.valueType = obj.valueType.replaceAll("\r", "");
-            obj.valueType = obj.valueType.replaceAll(")", "");
-            obj.valueType = obj.valueType.replaceAll(")", "");
-            obj.size = VertexAttributeSize[obj.valueType];
-            attributes.push(obj);
-        }
-        obj.format = VertexFormat[VertexAttributeSize[obj.valueType]];
-    }
-}

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

@@ -1,30 +0,0 @@
-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/src/gfx/graphics/webGpu/shader/value/ShaderState.js

@@ -1,113 +0,0 @@
-import { BlendMode } from "../../../../../materials/BlendMode";
-import { GPUCompareFunction, GPUCullMode, GPUPrimitiveTopology, } from "../../WebGPUConst";
-export class ShaderState {
-    constructor() {
-        this.blendMode = BlendMode.NONE;
-        this.depthCompare = GPUCompareFunction.less_equal;
-        this.depthWriteEnabled = true;
-        this.frontFace = `ccw`;
-        this.cullMode = GPUCullMode.back;
-        this.topology = GPUPrimitiveTopology.triangle_list;
-        this.depthBias = 10;
-        this.useLight = false;
-        this.useProbe = false;
-        this.acceptGI = false;
-        this.acceptShadow = false;
-        this.castShadow = false;
-        this.castReflection = true;
-        this.receiveEnv = false;
-        this.renderLayer = 1000;
-        this.renderOrder = 2000;
-        this.unclippedDepth = false;
-        this.transparent = false;
-        this.multisample = 0;
-        this.useZ = true;
-        this.splitTexture = false;
-        this.useFragDepth = false;
-        this.writeMasks = [];
-    }
-    setFromMapValues(values) {
-        if (values.has("blendMode")) {
-            this.blendMode = this.convertBlendMode(values.get("blendMode"));
-        }
-        if (values.has("depthCompare")) {
-            this.depthCompare = values.get("depthCompare");
-        }
-        if (values.has("depthWriteEnabled")) {
-            this.depthWriteEnabled = values.get("depthWriteEnabled");
-        }
-        if (values.has("frontFace")) {
-            this.frontFace = values.get("frontFace");
-        }
-        if (values.has("cullMode")) {
-            this.cullMode = values.get("cullMode");
-        }
-        if (values.has("topology")) {
-            this.topology = values.get("topology");
-        }
-        if (values.has("depthBias")) {
-            this.depthBias = values.get("depthBias");
-        }
-        if (values.has("useLight")) {
-            this.useLight = values.get("useLight");
-        }
-        if (values.has("useProbe")) {
-            this.useProbe = values.get("useProbe");
-        }
-        if (values.has("acceptGI")) {
-            this.acceptGI = values.get("acceptGI");
-        }
-        if (values.has("acceptShadow")) {
-            this.acceptShadow = values.get("acceptShadow");
-        }
-        if (values.has("castShadow")) {
-            this.castShadow = values.get("castShadow");
-        }
-        if (values.has("receiveEnv")) {
-            this.receiveEnv = values.get("receiveEnv");
-        }
-        if (values.has("renderLayer")) {
-            this.renderLayer = values.get("renderLayer");
-        }
-        if (values.has("renderOrder")) {
-            this.renderOrder = values.get("renderOrder");
-        }
-        if (values.has("unclippedDepth")) {
-            this.unclippedDepth = values.get("unclippedDepth");
-        }
-        if (values.has("multisample")) {
-            this.multisample = values.get("multisample");
-        }
-        if (values.has("label")) {
-            this.label = values.get("label");
-        }
-        if (values.has("useZ")) {
-            this.useZ = values.get("useZ");
-        }
-    }
-    convertBlendMode(value) {
-        switch (value) {
-            case "ABOVE":
-                return BlendMode.ABOVE;
-            case "ALPHA":
-                return BlendMode.ALPHA;
-            case "NORMAL":
-                return BlendMode.NORMAL;
-            case "ADD":
-                return BlendMode.ADD;
-            case "BELOW":
-                return BlendMode.BELOW;
-            case "ERASE":
-                return BlendMode.ERASE;
-            case "MUL":
-                return BlendMode.MUL;
-            case "SCREEN":
-                return BlendMode.SCREEN;
-            case "DIVD":
-                return BlendMode.DIVD;
-            case "SOFT_ADD":
-                return BlendMode.SOFT_ADD;
-        }
-        return BlendMode.NONE;
-    }
-}

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

@@ -1,32 +0,0 @@
-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/src/gfx/graphics/webGpu/shader/value/ShaderValue.js

@@ -1 +0,0 @@
-export {};

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

@@ -1,13 +0,0 @@
-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/src/gfx/graphics/webGpu/shader/value/UniformValue.js

@@ -1,9 +0,0 @@
-export var UniformType;
-(function (UniformType) {
-    UniformType[UniformType["Number"] = 0] = "Number";
-    UniformType[UniformType["Vector2"] = 1] = "Vector2";
-    UniformType[UniformType["Vector3"] = 2] = "Vector3";
-    UniformType[UniformType["Vector4"] = 3] = "Vector4";
-    UniformType[UniformType["Color"] = 4] = "Color";
-    UniformType[UniformType["Float32Array"] = 5] = "Float32Array";
-})(UniformType || (UniformType = {}));

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

@@ -1,32 +0,0 @@
-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;
-}