@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/loader/parser/prefab/mats/shader/LitSSSShader.js

@@ -0,0 +1,139 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Color } from "../../../../../math/Color";
+import { Vector4 } from "../../../../../math/Vector4";
+import { RegisterShader } from "../../../../../util/SerializeDecoration";
+import { Shader } from "../../../../../gfx/graphics/webGpu/shader/Shader";
+import { PBRLitSSSShader } from "../../../../../assets/shader/materials/PBRLitSSSShader";
+import { ShaderLib } from "../../../../../assets/shader/ShaderLib";
+import { PreIntegratedLutCompute } from "../../../../../gfx/graphics/webGpu/compute/PreIntegratedLutCompute";
+import { GPUCullMode } from "../../../../../gfx/graphics/webGpu/WebGPUConst";
+import { BlendMode } from "../../../../../materials/BlendMode";
+import { RenderShaderPass } from "../../../../../gfx/graphics/webGpu/shader/RenderShaderPass";
+/* eslint-disable */
+let LitSSSShader = class LitSSSShader extends Shader {
+    constructor() {
+        super();
+        ShaderLib.register("PBRLitSSSShader", PBRLitSSSShader);
+        let colorShader = new RenderShaderPass("PBRLitSSSShader", "PBRLitSSSShader");
+        colorShader.setShaderEntry(`VertMain`, `FragMain`);
+        this.addRenderPass(colorShader);
+        let shaderState = colorShader.shaderState;
+        shaderState.acceptShadow = true;
+        shaderState.castShadow = true;
+        shaderState.receiveEnv = true;
+        shaderState.acceptGI = true;
+        shaderState.useLight = true;
+        this.setDefine("USE_BRDF", true);
+        this.setDefine("USE_AO_R", true);
+        this.setDefine("USE_ROUGHNESS_G", true);
+        this.setDefine("USE_METALLIC_B", true);
+        this.setDefine("USE_ALPHA_A", true);
+        this.setDefine("USE_CUSTOMUNIFORM", true);
+        this.setDefault();
+        this.computes = [new PreIntegratedLutCompute(this)];
+    }
+    setDefault() {
+        this.setUniformFloat(`shadowBias`, 0.00035);
+        this.setUniformVector4(`transformUV1`, new Vector4(0, 0, 1, 1));
+        this.setUniformVector4(`transformUV2`, new Vector4(0, 0, 1, 1));
+        this.setUniformColor(`baseColor`, new Color());
+        this.setUniformColor(`emissiveColor`, new Color(1, 1, 1));
+        this.setUniformVector4(`materialF0`, new Vector4(0.04, 0.04, 0.04, 1));
+        this.setUniformColor(`specularColor`, new Color(0.04, 0.04, 0.04));
+        this.setUniformFloat(`envIntensity`, 1);
+        this.setUniformFloat(`normalScale`, 1);
+        this.setUniformFloat(`roughness`, 1.0);
+        this.setUniformFloat(`metallic`, 0.0);
+        this.setUniformFloat(`ao`, 1.0);
+        this.setUniformFloat(`roughness_min`, 0.0);
+        this.setUniformFloat(`roughness_max`, 1.0);
+        this.setUniformFloat(`metallic_min`, 0.0);
+        this.setUniformFloat(`metallic_max`, 1.0);
+        this.setUniformFloat(`emissiveIntensity`, 0.0);
+        this.setUniformFloat(`alphaCutoff`, 0.0);
+        this.setUniformFloat(`ior`, 1.5);
+        this.setUniformFloat(`clearcoatFactor`, 0.0);
+        this.setUniformFloat(`clearcoatRoughnessFactor`, 0.0);
+        this.setUniformColor(`clearcoatColor`, new Color(1, 1, 1));
+        this.setUniformFloat(`clearcoatWeight`, 0.0);
+        this.setUniformColor(`skinColor`, new Color(1, 0, 0));
+        this.setUniformFloat(`skinPower`, 3.4);
+        this.setUniformFloat(`skinColorIns`, 0.5);
+        this.setUniformFloat(`curveFactor`, 1.0);
+    }
+    set _MainTex(value) {
+        this.setTexture("baseMap", value);
+    }
+    set _BumpMap(value) {
+        this.setTexture("normalMap", value);
+    }
+    set _SSSMap(value) {
+        this.setTexture("sssMap", value);
+    }
+    set _MaskTex(value) {
+        this.setTexture("maskMap", value);
+    }
+    set _UVTransform(value) {
+        this.setUniformVector4("transformUV1", value);
+    }
+    set _Metallic(value) {
+        this.setUniformFloat("metallic", value);
+    }
+    set _Roughness(value) {
+        this.setUniformFloat("roughness", value);
+    }
+    set _MainColor(value) {
+        this.setUniformColor("baseColor", value);
+    }
+    set _AlphaCutoff(value) {
+        this.setUniformFloat("alphaCutoff", value);
+    }
+    set _DoubleSidedEnable(value) {
+        let shader = this.getDefaultColorShader();
+        shader.shaderState.cullMode = value
+            ? GPUCullMode.none
+            : shader.shaderState.cullMode;
+    }
+    set _SkinColor(value) {
+        this.setUniformColor("skinColor", value);
+    }
+    set _SkinPower(value) {
+        this.setUniformFloat("skinPower", value);
+    }
+    set _SkinColorIns(value) {
+        this.setUniformFloat("skinColorIns", value);
+    }
+    set curveFactor(value) {
+        this.setUniformFloat("curveFactor", value);
+    }
+    set _SurfaceType(value) {
+        let shader = this.getDefaultColorShader();
+        if (value == 0) {
+            shader.blendMode = BlendMode.NONE;
+        }
+        else {
+            shader.blendMode = BlendMode.ALPHA;
+        }
+    }
+    set _AlphaCutoffEnable(value) {
+        if (value == 0) {
+            this.setDefine("USE_ALPHACUT", false);
+        }
+        else {
+            this.setDefine("USE_ALPHACUT", true);
+        }
+    }
+};
+LitSSSShader = __decorate([
+    RegisterShader,
+    __metadata("design:paramtypes", [])
+], LitSSSShader);
+export { LitSSSShader };

package/dist/src/loader/parser/prefab/mats/shader/LitShader.d.ts

@@ -0,0 +1,19 @@
+import { Texture } from "../../../../../gfx/graphics/webGpu/core/texture/Texture";
+import { Color } from "../../../../../math/Color";
+import { Vector4 } from "../../../../../math/Vector4";
+import { Shader } from "../../../../../gfx/graphics/webGpu/shader/Shader";
+export declare class LitShader extends Shader {
+    constructor();
+    setDefault(): void;
+    set _MainTex(value: Texture);
+    set _BumpMap(value: Texture);
+    set _MaskTex(value: Texture);
+    set _UVTransform(value: Vector4);
+    set _Metallic(value: number);
+    set _Roughness(value: number);
+    set _MainColor(value: Color);
+    set _AlphaCutoff(value: number);
+    set _DoubleSidedEnable(value: number);
+    set _SurfaceType(value: number);
+    set _AlphaCutoffEnable(value: number);
+}

package/dist/src/loader/parser/prefab/mats/shader/LitShader.js

@@ -0,0 +1,117 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Engine3D } from "../../../../..";
+import { GPUCullMode } from "../../../../../gfx/graphics/webGpu/WebGPUConst";
+import { RenderShaderPass } from "../../../../../gfx/graphics/webGpu/shader/RenderShaderPass";
+import { BlendMode } from "../../../../../materials/BlendMode";
+import { Color } from "../../../../../math/Color";
+import { Vector4 } from "../../../../../math/Vector4";
+import { RegisterShader } from "../../../../../util/SerializeDecoration";
+import { Shader } from "../../../../../gfx/graphics/webGpu/shader/Shader";
+/* eslint-disable */
+let LitShader = class LitShader extends Shader {
+    constructor() {
+        super();
+        let colorShader = new RenderShaderPass("PBRLItShader", "PBRLItShader");
+        colorShader.setShaderEntry(`VertMain`, `FragMain`);
+        this.addRenderPass(colorShader);
+        let shaderState = colorShader.shaderState;
+        shaderState.acceptShadow = true;
+        shaderState.castShadow = true;
+        shaderState.receiveEnv = true;
+        shaderState.acceptGI = true;
+        shaderState.useLight = true;
+        this.setDefine("USE_BRDF", true);
+        this.setDefine("USE_ROUGHNESS_G", true);
+        this.setDefine("USE_METALLIC_B", true);
+        this.setDefine("USE_ALPHA_A", true);
+        this.setDefault();
+    }
+    setDefault() {
+        this.setUniformFloat(`shadowBias`, 0.00035);
+        this.setUniformVector4(`transformUV1`, new Vector4(0, 0, 1, 1));
+        this.setUniformVector4(`transformUV2`, new Vector4(0, 0, 1, 1));
+        this.setUniformColor(`baseColor`, new Color());
+        this.setUniformColor(`emissiveColor`, new Color(0, 0, 0));
+        this.setUniformVector4(`materialF0`, new Vector4(0.04, 0.04, 0.04, 1));
+        this.setUniformColor(`specularColor`, new Color(0.04, 0.04, 0.04));
+        this.setUniformFloat(`envIntensity`, 1);
+        this.setUniformFloat(`normalScale`, 1);
+        this.setUniformFloat(`roughness`, 1.0);
+        this.setUniformFloat(`metallic`, 0.0);
+        this.setUniformFloat(`ao`, 1.0);
+        this.setUniformFloat(`roughness_min`, 0.0);
+        this.setUniformFloat(`roughness_max`, 1.0);
+        this.setUniformFloat(`metallic_min`, 0.0);
+        this.setUniformFloat(`metallic_max`, 1.0);
+        this.setUniformFloat(`emissiveIntensity`, 0.0);
+        this.setUniformFloat(`alphaCutoff`, 0.0);
+        this.setUniformFloat(`ior`, 1.5);
+        this.setUniformFloat(`clearcoatFactor`, 0.0);
+        this.setUniformFloat(`clearcoatRoughnessFactor`, 0.0);
+        this.setUniformColor(`clearcoatColor`, new Color(1, 1, 1));
+        this.setUniformFloat(`clearcoatWeight`, 0.0);
+        this._MainTex = Engine3D.res.grayTexture;
+        this._BumpMap = Engine3D.res.normalTexture;
+        this._MaskTex = Engine3D.res.maskTexture;
+    }
+    set _MainTex(value) {
+        this.setTexture("baseMap", value);
+    }
+    set _BumpMap(value) {
+        this.setTexture("normalMap", value);
+    }
+    set _MaskTex(value) {
+        this.setTexture("maskMap", value);
+    }
+    set _UVTransform(value) {
+        this.setUniformVector4("transformUV1", value);
+    }
+    set _Metallic(value) {
+        this.setUniformFloat("metallic", value);
+    }
+    set _Roughness(value) {
+        this.setUniformFloat("roughness", value);
+    }
+    set _MainColor(value) {
+        this.setUniformColor("baseColor", value);
+    }
+    set _AlphaCutoff(value) {
+        this.setUniformFloat("alphaCutoff", value);
+    }
+    set _DoubleSidedEnable(value) {
+        let subShader = this.getDefaultColorShader();
+        subShader.shaderState.cullMode = value
+            ? GPUCullMode.none
+            : subShader.shaderState.cullMode;
+    }
+    set _SurfaceType(value) {
+        let subShader = this.getDefaultColorShader();
+        if (value == 0) {
+            subShader.blendMode = BlendMode.NONE;
+        }
+        else {
+            subShader.blendMode = BlendMode.ALPHA;
+        }
+    }
+    set _AlphaCutoffEnable(value) {
+        if (value == 0) {
+            this.setDefine("USE_ALPHACUT", false);
+        }
+        else {
+            this.setDefine("USE_ALPHACUT", true);
+        }
+    }
+};
+LitShader = __decorate([
+    RegisterShader(),
+    __metadata("design:paramtypes", [])
+], LitShader);
+export { LitShader };

package/dist/src/loader/parser/prefab/mats/shader/QuadShader.d.ts

@@ -0,0 +1,4 @@
+import { Shader } from "../../../../../gfx/graphics/webGpu/shader/Shader";
+export declare class QuadShader extends Shader {
+    constructor(vs?: string, fs?: string);
+}

package/dist/src/loader/parser/prefab/mats/shader/QuadShader.js

@@ -0,0 +1,39 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Engine3D } from "../../../../../Engine3D";
+import { GPUCompareFunction } from "../../../../../gfx/graphics/webGpu/WebGPUConst";
+import { RenderShaderPass } from "../../../../../gfx/graphics/webGpu/shader/RenderShaderPass";
+import { BlendMode } from "../../../../../materials/BlendMode";
+import { RegisterShader } from "../../../../../util/SerializeDecoration";
+import { Shader } from "../../../../../gfx/graphics/webGpu/shader/Shader";
+/* eslint-disable */
+let QuadShader = class QuadShader extends Shader {
+    constructor(vs = "QuadGlsl_vs", fs = "QuadGlsl_fs") {
+        super();
+        let colorShader = new RenderShaderPass(vs, fs);
+        this.addRenderPass(colorShader);
+        let shaderState = colorShader.shaderState;
+        colorShader.blendMode = BlendMode.NONE;
+        shaderState.frontFace = `cw`;
+        shaderState.depthWriteEnabled = false;
+        shaderState.depthCompare = GPUCompareFunction.always;
+        shaderState.multisample = 0;
+        this.setTexture("baseMap", Engine3D.res.blackTexture);
+        this.setUniformFloat(`x`, 0);
+        this.setUniformFloat(`y`, 0);
+        this.setUniformFloat(`width`, 100);
+        this.setUniformFloat(`height`, 100);
+    }
+};
+QuadShader = __decorate([
+    RegisterShader,
+    __metadata("design:paramtypes", [String, String])
+], QuadShader);
+export { QuadShader };

package/dist/src/loader/parser/prefab/mats/shader/ReflectionShader.d.ts

@@ -0,0 +1,19 @@
+import { Texture } from "../../../../../gfx/graphics/webGpu/core/texture/Texture";
+import { Color } from "../../../../../math/Color";
+import { Vector4 } from "../../../../../math/Vector4";
+import { Shader } from "../../../../../gfx/graphics/webGpu/shader/Shader";
+export declare class ReflectionShader extends Shader {
+    constructor();
+    setDefault(): void;
+    set _MainTex(value: Texture);
+    set _BumpMap(value: Texture);
+    set _MaskTex(value: Texture);
+    set _UVTransform(value: Vector4);
+    set _Metallic(value: number);
+    set _Roughness(value: number);
+    set _MainColor(value: Color);
+    set _AlphaCutoff(value: number);
+    set _DoubleSidedEnable(value: number);
+    set _SurfaceType(value: number);
+    set _AlphaCutoffEnable(value: number);
+}

package/dist/src/loader/parser/prefab/mats/shader/ReflectionShader.js

@@ -0,0 +1,79 @@
+import { GPUCullMode } from "../../../../../gfx/graphics/webGpu/WebGPUConst";
+import { RenderShaderPass } from "../../../../../gfx/graphics/webGpu/shader/RenderShaderPass";
+import { BlendMode } from "../../../../../materials/BlendMode";
+import { Color } from "../../../../../math/Color";
+import { Vector4 } from "../../../../../math/Vector4";
+import { Shader } from "../../../../../gfx/graphics/webGpu/shader/Shader";
+export class ReflectionShader extends Shader {
+    constructor() {
+        super();
+        let colorShader = new RenderShaderPass("ReflectionShader_shader", "ReflectionShader_shader");
+        colorShader.setShaderEntry(`VertMain`, `FragMain`);
+        this.addRenderPass(colorShader);
+        let shaderState = colorShader.shaderState;
+        shaderState.acceptShadow = false;
+        shaderState.castShadow = false;
+        shaderState.receiveEnv = false;
+        shaderState.acceptGI = false;
+        shaderState.useLight = false;
+        this.setDefine("USE_BRDF", true);
+        this.setDefine("USE_AO_R", true);
+        this.setDefine("USE_ROUGHNESS_G", true);
+        this.setDefine("USE_METALLIC_B", true);
+        this.setDefine("USE_ALPHA_A", true);
+        this.setDefault();
+    }
+    setDefault() {
+        this.setUniformVector4(`transformUV1`, new Vector4(0, 0, 1, 1));
+        this.setUniformVector4(`transformUV2`, new Vector4(0, 0, 1, 1));
+        this.setUniformColor(`baseColor`, new Color());
+        this.setUniformFloat(`alphaCutoff`, 0.0);
+    }
+    set _MainTex(value) {
+        this.setTexture("baseMap", value);
+    }
+    set _BumpMap(value) {
+        this.setTexture("normalMap", value);
+    }
+    set _MaskTex(value) {
+        this.setTexture("maskMap", value);
+    }
+    set _UVTransform(value) {
+        this.setUniformVector4("transformUV1", value);
+    }
+    set _Metallic(value) {
+        this.setUniformFloat("metallic", value);
+    }
+    set _Roughness(value) {
+        this.setUniformFloat("roughness", value);
+    }
+    set _MainColor(value) {
+        this.setUniformColor("baseColor", value);
+    }
+    set _AlphaCutoff(value) {
+        this.setUniformFloat("alphaCutoff", value);
+    }
+    set _DoubleSidedEnable(value) {
+        let defaultShader = this.getDefaultColorShader();
+        defaultShader.shaderState.cullMode = value
+            ? GPUCullMode.none
+            : defaultShader.shaderState.cullMode;
+    }
+    set _SurfaceType(value) {
+        let defaultShader = this.getDefaultColorShader();
+        if (value == 0) {
+            defaultShader.blendMode = BlendMode.NONE;
+        }
+        else {
+            defaultShader.blendMode = BlendMode.ALPHA;
+        }
+    }
+    set _AlphaCutoffEnable(value) {
+        if (value == 0) {
+            this.setDefine("USE_ALPHACUT", false);
+        }
+        else {
+            this.setDefine("USE_ALPHACUT", true);
+        }
+    }
+}

package/dist/src/loader/parser/prefab/mats/shader/SkyShader.d.ts

@@ -0,0 +1,4 @@
+import { Shader } from "../../../../../gfx/graphics/webGpu/shader/Shader";
+export declare class SkyShader extends Shader {
+    constructor();
+}

package/dist/src/loader/parser/prefab/mats/shader/SkyShader.js

@@ -0,0 +1,35 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { GPUCompareFunction, GPUCullMode, } from "../../../../../gfx/graphics/webGpu/WebGPUConst";
+import { RenderShaderPass } from "../../../../../gfx/graphics/webGpu/shader/RenderShaderPass";
+import { Vector3 } from "../../../../../math/Vector3";
+import { RegisterShader } from "../../../../../util/SerializeDecoration";
+import { Shader } from "../../../../../gfx/graphics/webGpu/shader/Shader";
+/* eslint-disable */
+let SkyShader = class SkyShader extends Shader {
+    constructor() {
+        super();
+        let colorShader = new RenderShaderPass("sky_vs_frag_wgsl", "sky_fs_frag_wgsl");
+        this.addRenderPass(colorShader);
+        colorShader.setUniformVector3(`eyesPos`, new Vector3());
+        colorShader.setUniformFloat(`exposure`, 1.0);
+        colorShader.setUniformFloat(`roughness`, 0.0);
+        let shaderState = colorShader.shaderState;
+        shaderState.frontFace = `cw`;
+        shaderState.cullMode = GPUCullMode.back;
+        shaderState.depthWriteEnabled = false;
+        shaderState.depthCompare = GPUCompareFunction.less;
+    }
+};
+SkyShader = __decorate([
+    RegisterShader,
+    __metadata("design:paramtypes", [])
+], SkyShader);
+export { SkyShader };

package/dist/src/loader/parser/prefab/mats/shader/StandShader.d.ts

@@ -0,0 +1,220 @@
+import { Texture } from "../../../../../gfx/graphics/webGpu/core/texture/Texture";
+import { Color } from "../../../../../math/Color";
+import { Vector4 } from "../../../../../math/Vector4";
+import { Shader } from "../../../../../gfx/graphics/webGpu/shader/Shader";
+export declare class StandShader extends Shader {
+    constructor();
+    setDefault(): void;
+    get baseMap(): Texture;
+    set baseMap(value: Texture);
+    get baseColor(): Color;
+    set baseColor(value: Color);
+    get normalMap(): Texture;
+    set normalMap(value: Texture);
+    get doubleSide(): boolean;
+    set doubleSide(value: boolean);
+    get alphaCutoff(): any;
+    set alphaCutoff(value: any);
+    get emissiveColor(): Color;
+    set emissiveColor(value: Color);
+    get emissiveIntensity(): number;
+    set emissiveIntensity(value: number);
+    /**
+     * get transformUV1
+     */
+    get transformUV1(): Vector4;
+    /**
+     * set transformUV1
+     */
+    set transformUV1(value: Vector4);
+    /**
+     * get transformUV2
+     */
+    get uvTransform_2(): Vector4;
+    /**
+     * set transformUV2
+     */
+    set uvTransform_2(value: Vector4);
+    get depthWriteEnabled(): boolean;
+    set depthWriteEnabled(value: boolean);
+    /**
+     * get reflectivity
+     */
+    get materialF0(): Vector4;
+    /**
+     * set reflectivity
+     */
+    set materialF0(value: Vector4);
+    /**
+     * get specularColor
+     */
+    get specularColor(): Color;
+    /**specularColor
+     * set reflectivity
+     */
+    set specularColor(value: Color);
+    /**
+     * get roughness
+     */
+    get roughness(): number;
+    /**
+     * set roughness
+     */
+    set roughness(value: number);
+    /**
+     * get metallic
+     */
+    get metallic(): number;
+    /**
+     * set metallic
+     */
+    set metallic(value: number);
+    /**
+     * get Ambient Occlussion, dealing with the effect of ambient light on object occlusion
+     */
+    get ao(): number;
+    /**
+     * set Ambient Occlussion, dealing with the effect of ambient light on object occlusion
+     */
+    set ao(value: number);
+    /**
+     * get min metallic
+     */
+    get metallic_min(): number;
+    /**
+     * set min metallic
+     */
+    set metallic_min(value: number);
+    /**
+     * get max metallic
+     */
+    get metallic_max(): number;
+    /**
+     * set max metallic
+     */
+    set metallic_max(value: number);
+    /**
+     * get min roughness
+     */
+    get roughness_min(): number;
+    /**
+     * set min roughness
+     */
+    set roughness_min(value: number);
+    /**
+     * get max roughness
+     */
+    get roughness_max(): number;
+    /**
+     * set max roughness
+     */
+    set roughness_max(value: number);
+    /**
+     * Get the influence of Normal mapping on materials
+     */
+    get normalScale(): number;
+    /**
+     * Set the influence of Normal mapping on materials
+     */
+    set normalScale(value: number);
+    /**
+     * get Mask Map
+     * R_chanel -> AoMap
+     * G_chanel -> Roughness
+     * B_chanel -> Metallic
+     * A_chanel -> C
+     */
+    get maskMap(): Texture;
+    /**
+     * set Mask Map
+     * R_chanel -> AoMap
+     * G_chanel -> Roughness
+     * B_chanel -> Metallic
+     * A_chanel -> C
+     */
+    set maskMap(value: Texture);
+    /**
+     * set Ambient Occlussion Map, dealing with the effect of ambient light on object occlusion
+     */
+    set aoMap(value: Texture);
+    /**
+     * get Ambient Occlussion Map, dealing with the effect of ambient light on object occlusion
+     */
+    get aoMap(): Texture;
+    /**
+     * set clearCoatRoughnessMap
+     */
+    set clearCoatRoughnessMap(value: Texture);
+    /**
+     * get clearCoatRoughnessMap
+     */
+    get clearCoatRoughnessMap(): Texture;
+    /**
+     * get brdf query map
+     */
+    get brdfLUT(): Texture;
+    /**
+     * set brdf query map
+     */
+    set brdfLUT(value: Texture);
+    /**
+     * get emissive map
+     */
+    get emissiveMap(): Texture;
+    /**
+     * set emissive map
+     */
+    set emissiveMap(value: Texture);
+    /**
+     * set intensity of environment light or color of sampled by texture
+     */
+    set envIntensity(value: number);
+    /**
+     * get intensity of environment light or color of sampled by texture
+     */
+    get envIntensity(): number;
+    /**
+     * set factor of refractive
+     */
+    set ior(value: number);
+    /**
+     * get factor of refractive
+     */
+    get ior(): number;
+    /**
+     * valid USE_CLEARCOAT define in shader
+     */
+    useCleanCoat(): void;
+    /**
+     * Set the factor of the clearcoat
+     */
+    set clearcoatFactor(value: number);
+    /**
+     * get the factor of the clearcoat
+     */
+    get clearcoatFactor(): number;
+    /**
+     * set the factor of the clearcoat Roughness
+     */
+    set clearcoatRoughnessFactor(value: number);
+    /**
+     * get the factor of the clearcoat Roughness
+     */
+    get clearcoatRoughnessFactor(): number;
+    /**
+     * set the weight of the clearcoat
+     */
+    set clearcoatWeight(value: number);
+    /**
+     * get the weight of the clearcoat
+     */
+    get clearcoatWeight(): number;
+    /**
+     * get the color of the clearcoat
+     */
+    set clearcoatColor(value: Color);
+    /**
+     * set the color of the clearcoat
+     */
+    get clearcoatColor(): Color;
+}