@galacean/engine-core 1.3.0-alpha.1 → 1.3.0-alpha.2

package/dist/module.js

@@ -2990,6 +2990,12 @@ var RenderStateElementKey;
     StencilOperation[StencilOperation[/** Decrements the current stencil buffer value. Wraps stencil buffer value to the maximum representable unsigned value when decrementing a stencil buffer value of 0. */ "DecrementWrap"] = 7] = "DecrementWrap";
 })(StencilOperation || (StencilOperation = {}));
 
+var ShaderPlatformTarget;
+(function(ShaderPlatformTarget) {
+    ShaderPlatformTarget[ShaderPlatformTarget["GLES100"] = 0] = "GLES100";
+    ShaderPlatformTarget[ShaderPlatformTarget["GLES300"] = 1] = "GLES300";
+})(ShaderPlatformTarget || (ShaderPlatformTarget = {}));
+
 /**
  * Shader macro。
  */ var ShaderMacro = /*#__PURE__*/ function() {
@@ -3019,14 +3025,14 @@ var RenderStateElementKey;
                 maskMap.length++;
                 maskMap[index] = new Array(32);
             }
-            maskMap[index][bit] = key;
+            maskMap[index][bit] = macro;
             ShaderMacro._macroCounter++;
         }
         return macro;
     };
     /**
    * @internal
-   */ ShaderMacro._getNamesByMacros = function _getNamesByMacros(macros, out) {
+   */ ShaderMacro._getMacrosElements = function _getMacrosElements(macros, out) {
         var maskMap = ShaderMacro._macroMaskMap;
         var mask = macros._mask;
         out.length = 0;
@@ -3209,15 +3215,6 @@ var RenderStateElementKey;
     return ShaderMacroCollection;
 }();
 
-/**
- * Pipeline stage.
- */ var PipelineStage;
-(function(PipelineStage) {
-    PipelineStage[/** DepthOnly stage. */ "DepthOnly"] = "DepthOnly";
-    PipelineStage[/** Shadow caster stage. */ "ShadowCaster"] = "ShadowCaster";
-    PipelineStage[/** Forward shading stage. */ "Forward"] = "Forward";
-})(PipelineStage || (PipelineStage = {}));
-
 function _extends() {
     _extends = Object.assign || function assign(target) {
         for (var i = 1; i < arguments.length; i++) {
@@ -3231,6 +3228,15 @@ function _extends() {
     return _extends.apply(this, arguments);
 }
 
+/**
+ * Pipeline stage.
+ */ var PipelineStage;
+(function(PipelineStage) {
+    PipelineStage[/** DepthOnly stage. */ "DepthOnly"] = "DepthOnly";
+    PipelineStage[/** Shadow caster stage. */ "ShadowCaster"] = "ShadowCaster";
+    PipelineStage[/** Forward shading stage. */ "Forward"] = "Forward";
+})(PipelineStage || (PipelineStage = {}));
+
 var camera_declare = "#define GLSLIFY 1\nuniform vec3 camera_Position;uniform vec3 camera_Forward;uniform vec4 camera_ProjectionParams;"; // eslint-disable-line
 
 var common = "#define GLSLIFY 1\n#define PI 3.14159265359\n#define RECIPROCAL_PI 0.31830988618\n#define EPSILON 1e-6\n#define LOG2 1.442695\n#define saturate( a ) clamp( a, 0.0, 1.0 )\nfloat pow2(float x){return x*x;}vec4 RGBMToLinear(vec4 value,float maxRange){return vec4(value.rgb*value.a*maxRange,1.0);}vec4 gammaToLinear(vec4 srgbIn){return vec4(pow(srgbIn.rgb,vec3(2.2)),srgbIn.a);}vec4 linearToGamma(vec4 linearIn){return vec4(pow(linearIn.rgb,vec3(1.0/2.2)),linearIn.a);}uniform vec4 camera_DepthBufferParams;float remapDepthBufferLinear01(float z){return 1.0/(camera_DepthBufferParams.x*z+camera_DepthBufferParams.y);}\n#ifdef GRAPHICS_API_WEBGL2\n#define INVERSE_MAT(mat) inverse(mat)\n#else\nmat2 inverseMat(mat2 m){return mat2(m[1][1],-m[0][1],-m[1][0],m[0][0])/(m[0][0]*m[1][1]-m[0][1]*m[1][0]);}mat3 inverseMat(mat3 m){float a00=m[0][0],a01=m[0][1],a02=m[0][2];float a10=m[1][0],a11=m[1][1],a12=m[1][2];float a20=m[2][0],a21=m[2][1],a22=m[2][2];float b01=a22*a11-a12*a21;float b11=-a22*a10+a12*a20;float b21=a21*a10-a11*a20;float det=a00*b01+a01*b11+a02*b21;return mat3(b01,(-a22*a01+a02*a21),(a12*a01-a02*a11),b11,(a22*a00-a02*a20),(-a12*a00+a02*a10),b21,(-a21*a00+a01*a20),(a11*a00-a01*a10))/det;}mat4 inverseMat(mat4 m){float a00=m[0][0],a01=m[0][1],a02=m[0][2],a03=m[0][3],a10=m[1][0],a11=m[1][1],a12=m[1][2],a13=m[1][3],a20=m[2][0],a21=m[2][1],a22=m[2][2],a23=m[2][3],a30=m[3][0],a31=m[3][1],a32=m[3][2],a33=m[3][3],b00=a00*a11-a01*a10,b01=a00*a12-a02*a10,b02=a00*a13-a03*a10,b03=a01*a12-a02*a11,b04=a01*a13-a03*a11,b05=a02*a13-a03*a12,b06=a20*a31-a21*a30,b07=a20*a32-a22*a30,b08=a20*a33-a23*a30,b09=a21*a32-a22*a31,b10=a21*a33-a23*a31,b11=a22*a33-a23*a32,det=b00*b11-b01*b10+b02*b09+b03*b08-b04*b07+b05*b06;return mat4(a11*b11-a12*b10+a13*b09,a02*b10-a01*b11-a03*b09,a31*b05-a32*b04+a33*b03,a22*b04-a21*b05-a23*b03,a12*b08-a10*b11-a13*b07,a00*b11-a02*b08+a03*b07,a32*b02-a30*b05-a33*b01,a20*b05-a22*b02+a23*b01,a10*b10-a11*b08+a13*b06,a01*b08-a00*b10-a03*b06,a30*b04-a31*b02+a33*b00,a21*b02-a20*b04-a23*b00,a11*b07-a10*b09-a12*b06,a00*b09-a01*b07+a02*b06,a31*b01-a30*b03-a32*b00,a20*b03-a21*b01+a22*b00)/det;}\n#define INVERSE_MAT(mat) inverseMat(mat)\n#endif\n"; // eslint-disable-line
@@ -3325,7 +3331,7 @@ var brdf = "#define GLSLIFY 1\nfloat F_Schlick(float f0,float dotLH){return f0+0
 
 var direct_irradiance_frag_define = "#define GLSLIFY 1\n#include <ShadowFragmentDeclaration>\nvoid addDirectRadiance(vec3 incidentDirection,vec3 color,Geometry geometry,Material material,inout ReflectedLight reflectedLight){float attenuation=1.0;\n#ifdef MATERIAL_ENABLE_CLEAR_COAT\nfloat clearCoatDotNL=saturate(dot(geometry.clearCoatNormal,incidentDirection));vec3 clearCoatIrradiance=clearCoatDotNL*color;reflectedLight.directSpecular+=material.clearCoat*clearCoatIrradiance*BRDF_Specular_GGX(incidentDirection,geometry,geometry.clearCoatNormal,vec3(0.04),material.clearCoatRoughness);attenuation-=material.clearCoat*F_Schlick(material.f0,geometry.clearCoatDotNV);\n#endif\nfloat dotNL=saturate(dot(geometry.normal,incidentDirection));vec3 irradiance=dotNL*color*PI;reflectedLight.directSpecular+=attenuation*irradiance*BRDF_Specular_GGX(incidentDirection,geometry,geometry.normal,material.specularColor,material.roughness);reflectedLight.directDiffuse+=attenuation*irradiance*BRDF_Diffuse_Lambert(material.diffuseColor);}\n#ifdef SCENE_DIRECT_LIGHT_COUNT\nvoid addDirectionalDirectLightRadiance(DirectLight directionalLight,Geometry geometry,Material material,inout ReflectedLight reflectedLight){vec3 color=directionalLight.color;vec3 direction=-directionalLight.direction;addDirectRadiance(direction,color,geometry,material,reflectedLight);}\n#endif\n#ifdef SCENE_POINT_LIGHT_COUNT\nvoid addPointDirectLightRadiance(PointLight pointLight,Geometry geometry,Material material,inout ReflectedLight reflectedLight){vec3 lVector=pointLight.position-geometry.position;vec3 direction=normalize(lVector);float lightDistance=length(lVector);vec3 color=pointLight.color;color*=clamp(1.0-pow(lightDistance/pointLight.distance,4.0),0.0,1.0);addDirectRadiance(direction,color,geometry,material,reflectedLight);}\n#endif\n#ifdef SCENE_SPOT_LIGHT_COUNT\nvoid addSpotDirectLightRadiance(SpotLight spotLight,Geometry geometry,Material material,inout ReflectedLight reflectedLight){vec3 lVector=spotLight.position-geometry.position;vec3 direction=normalize(lVector);float lightDistance=length(lVector);float angleCos=dot(direction,-spotLight.direction);float spotEffect=smoothstep(spotLight.penumbraCos,spotLight.angleCos,angleCos);float decayEffect=clamp(1.0-pow(lightDistance/spotLight.distance,4.0),0.0,1.0);vec3 color=spotLight.color;color*=spotEffect*decayEffect;addDirectRadiance(direction,color,geometry,material,reflectedLight);}\n#endif\nvoid addTotalDirectRadiance(Geometry geometry,Material material,inout ReflectedLight reflectedLight){float shadowAttenuation=1.0;\n#ifdef SCENE_DIRECT_LIGHT_COUNT\nshadowAttenuation=1.0;\n#ifdef SCENE_IS_CALCULATE_SHADOWS\nshadowAttenuation*=sampleShadowMap();\n#endif\nDirectLight directionalLight;for(int i=0;i<SCENE_DIRECT_LIGHT_COUNT;i++){if(!isRendererCulledByLight(renderer_Layer.xy,scene_DirectLightCullingMask[i])){directionalLight.color=scene_DirectLightColor[i];\n#ifdef SCENE_IS_CALCULATE_SHADOWS\nif(i==0){directionalLight.color*=shadowAttenuation;}\n#endif\ndirectionalLight.direction=scene_DirectLightDirection[i];addDirectionalDirectLightRadiance(directionalLight,geometry,material,reflectedLight);}}\n#endif\n#ifdef SCENE_POINT_LIGHT_COUNT\nPointLight pointLight;for(int i=0;i<SCENE_POINT_LIGHT_COUNT;i++){if(!isRendererCulledByLight(renderer_Layer.xy,scene_PointLightCullingMask[i])){pointLight.color=scene_PointLightColor[i];pointLight.position=scene_PointLightPosition[i];pointLight.distance=scene_PointLightDistance[i];addPointDirectLightRadiance(pointLight,geometry,material,reflectedLight);}}\n#endif\n#ifdef SCENE_SPOT_LIGHT_COUNT\nSpotLight spotLight;for(int i=0;i<SCENE_SPOT_LIGHT_COUNT;i++){if(!isRendererCulledByLight(renderer_Layer.xy,scene_SpotLightCullingMask[i])){spotLight.color=scene_SpotLightColor[i];spotLight.position=scene_SpotLightPosition[i];spotLight.direction=scene_SpotLightDirection[i];spotLight.distance=scene_SpotLightDistance[i];spotLight.angleCos=scene_SpotLightAngleCos[i];spotLight.penumbraCos=scene_SpotLightPenumbraCos[i];addSpotDirectLightRadiance(spotLight,geometry,material,reflectedLight);}}\n#endif\n}"; // eslint-disable-line
 
-var ibl_frag_define = "#define GLSLIFY 1\nvec3 getLightProbeIrradiance(vec3 sh[9],vec3 normal){normal.x=-normal.x;vec3 result=sh[0]+sh[1]*(normal.y)+sh[2]*(normal.z)+sh[3]*(normal.x)+sh[4]*(normal.y*normal.x)+sh[5]*(normal.y*normal.z)+sh[6]*(3.0*normal.z*normal.z-1.0)+sh[7]*(normal.z*normal.x)+sh[8]*(normal.x*normal.x-normal.y*normal.y);return max(result,vec3(0.0));}vec3 envBRDFApprox(vec3 specularColor,float roughness,float dotNV){const vec4 c0=vec4(-1,-0.0275,-0.572,0.022);const vec4 c1=vec4(1,0.0425,1.04,-0.04);vec4 r=roughness*c0+c1;float a004=min(r.x*r.x,exp2(-9.28*dotNV))*r.x+r.y;vec2 AB=vec2(-1.04,1.04)*a004+r.zw;return specularColor*AB.x+AB.y;}float getSpecularMIPLevel(float roughness,int maxMIPLevel){return roughness*float(maxMIPLevel);}vec3 getReflectedVector(Geometry geometry,vec3 n){\n#ifdef MATERIAL_ENABLE_ANISOTROPY\nvec3 r=reflect(-geometry.viewDir,geometry.anisotropicN);\n#else\nvec3 r=reflect(-geometry.viewDir,n);\n#endif\nreturn r;}vec3 getLightProbeRadiance(Geometry geometry,vec3 normal,float roughness,int maxMIPLevel,float specularIntensity){\n#ifndef SCENE_USE_SPECULAR_ENV\nreturn vec3(0);\n#else\nvec3 reflectVec=getReflectedVector(geometry,normal);reflectVec.x=-reflectVec.x;float specularMIPLevel=getSpecularMIPLevel(roughness,maxMIPLevel);\n#ifdef HAS_TEX_LOD\nvec4 envMapColor=textureCubeLodEXT(scene_EnvSpecularSampler,reflectVec,specularMIPLevel);\n#else\nvec4 envMapColor=textureCube(scene_EnvSpecularSampler,reflectVec,specularMIPLevel);\n#endif\n#ifdef SCENE_IS_DECODE_ENV_RGBM\nenvMapColor.rgb=RGBMToLinear(envMapColor,5.0).rgb;\n#ifdef ENGINE_IS_COLORSPACE_GAMMA\nenvMapColor=linearToGamma(envMapColor);\n#endif\n#else\n#ifndef ENGINE_IS_COLORSPACE_GAMMA\nenvMapColor=gammaToLinear(envMapColor);\n#endif\n#endif\nreturn envMapColor.rgb*specularIntensity;\n#endif\n}"; // eslint-disable-line
+var ibl_frag_define = "#define GLSLIFY 1\nvec3 getLightProbeIrradiance(vec3 sh[9],vec3 normal){normal.x=-normal.x;vec3 result=sh[0]+sh[1]*(normal.y)+sh[2]*(normal.z)+sh[3]*(normal.x)+sh[4]*(normal.y*normal.x)+sh[5]*(normal.y*normal.z)+sh[6]*(3.0*normal.z*normal.z-1.0)+sh[7]*(normal.z*normal.x)+sh[8]*(normal.x*normal.x-normal.y*normal.y);return max(result,vec3(0.0));}vec3 envBRDFApprox(vec3 specularColor,float roughness,float dotNV){const vec4 c0=vec4(-1,-0.0275,-0.572,0.022);const vec4 c1=vec4(1,0.0425,1.04,-0.04);vec4 r=roughness*c0+c1;float a004=min(r.x*r.x,exp2(-9.28*dotNV))*r.x+r.y;vec2 AB=vec2(-1.04,1.04)*a004+r.zw;return max(specularColor*AB.x+AB.y,0.0);}float getSpecularMIPLevel(float roughness,int maxMIPLevel){return roughness*float(maxMIPLevel);}vec3 getReflectedVector(Geometry geometry,vec3 n){\n#ifdef MATERIAL_ENABLE_ANISOTROPY\nvec3 r=reflect(-geometry.viewDir,geometry.anisotropicN);\n#else\nvec3 r=reflect(-geometry.viewDir,n);\n#endif\nreturn r;}vec3 getLightProbeRadiance(Geometry geometry,vec3 normal,float roughness,int maxMIPLevel,float specularIntensity){\n#ifndef SCENE_USE_SPECULAR_ENV\nreturn vec3(0);\n#else\nvec3 reflectVec=getReflectedVector(geometry,normal);reflectVec.x=-reflectVec.x;float specularMIPLevel=getSpecularMIPLevel(roughness,maxMIPLevel);\n#ifdef HAS_TEX_LOD\nvec4 envMapColor=textureCubeLodEXT(scene_EnvSpecularSampler,reflectVec,specularMIPLevel);\n#else\nvec4 envMapColor=textureCube(scene_EnvSpecularSampler,reflectVec,specularMIPLevel);\n#endif\n#ifdef SCENE_IS_DECODE_ENV_RGBM\nenvMapColor.rgb=RGBMToLinear(envMapColor,5.0).rgb;\n#ifdef ENGINE_IS_COLORSPACE_GAMMA\nenvMapColor=linearToGamma(envMapColor);\n#endif\n#else\n#ifndef ENGINE_IS_COLORSPACE_GAMMA\nenvMapColor=gammaToLinear(envMapColor);\n#endif\n#endif\nreturn envMapColor.rgb*specularIntensity;\n#endif\n}"; // eslint-disable-line
 
 var pbr_frag = "#define GLSLIFY 1\nGeometry geometry;Material material;ReflectedLight reflectedLight=ReflectedLight(vec3(0.0),vec3(0.0),vec3(0.0),vec3(0.0));initGeometry(geometry,gl_FrontFacing);initMaterial(material,geometry);addTotalDirectRadiance(geometry,material,reflectedLight);\n#ifdef SCENE_USE_SH\nvec3 irradiance=getLightProbeIrradiance(scene_EnvSH,geometry.normal);\n#ifdef ENGINE_IS_COLORSPACE_GAMMA\nirradiance=linearToGamma(vec4(irradiance,1.0)).rgb;\n#endif\nirradiance*=scene_EnvMapLight.diffuseIntensity;\n#else\nvec3 irradiance=scene_EnvMapLight.diffuse*scene_EnvMapLight.diffuseIntensity;irradiance*=PI;\n#endif\nreflectedLight.indirectDiffuse+=irradiance*BRDF_Diffuse_Lambert(material.diffuseColor);vec3 radiance=getLightProbeRadiance(geometry,geometry.normal,material.roughness,int(scene_EnvMapLight.mipMapLevel),scene_EnvMapLight.specularIntensity);float radianceAttenuation=1.0;\n#ifdef MATERIAL_ENABLE_CLEAR_COAT\nvec3 clearCoatRadiance=getLightProbeRadiance(geometry,geometry.clearCoatNormal,material.clearCoatRoughness,int(scene_EnvMapLight.mipMapLevel),scene_EnvMapLight.specularIntensity);reflectedLight.indirectSpecular+=clearCoatRadiance*material.clearCoat*envBRDFApprox(vec3(0.04),material.clearCoatRoughness,geometry.clearCoatDotNV);radianceAttenuation-=material.clearCoat*F_Schlick(material.f0,geometry.clearCoatDotNV);\n#endif\nreflectedLight.indirectSpecular+=radianceAttenuation*radiance*envBRDFApprox(material.specularColor,material.roughness,geometry.dotNV);\n#ifdef MATERIAL_HAS_OCCLUSION_TEXTURE\nvec2 aoUV=v_uv;\n#ifdef RENDERER_HAS_UV1\nif(material_OcclusionTextureCoord==1.0){aoUV=v_uv1;}\n#endif\nfloat ambientOcclusion=(texture2D(material_OcclusionTexture,aoUV).r-1.0)*material_OcclusionIntensity+1.0;reflectedLight.indirectDiffuse*=ambientOcclusion;\n#ifdef SCENE_USE_SPECULAR_ENV\nreflectedLight.indirectSpecular*=computeSpecularOcclusion(ambientOcclusion,material.roughness,geometry.dotNV);\n#endif\n#endif\nvec3 emissiveRadiance=material_EmissiveColor;\n#ifdef MATERIAL_HAS_EMISSIVETEXTURE\nvec4 emissiveColor=texture2D(material_EmissiveTexture,v_uv);\n#ifndef ENGINE_IS_COLORSPACE_GAMMA\nemissiveColor=gammaToLinear(emissiveColor);\n#endif\nemissiveRadiance*=emissiveColor.rgb;\n#endif\nvec3 totalRadiance=reflectedLight.directDiffuse+reflectedLight.indirectDiffuse+reflectedLight.directSpecular+reflectedLight.indirectSpecular+emissiveRadiance;vec4 targetColor=vec4(totalRadiance,material.opacity);gl_FragColor=targetColor;"; // eslint-disable-line
 
@@ -3446,7 +3452,7 @@ var ShaderFactory = /*#__PURE__*/ function() {
     function ShaderFactory() {}
     ShaderFactory.parseCustomMacros = function parseCustomMacros(macros) {
         return macros.map(function(m) {
-            return "#define " + m + "\n";
+            return "#define " + (m.value ? m.name + " " + m.value : m.name) + "\n";
         }).join("");
     };
     ShaderFactory.registerInclude = function registerInclude(includeName, includeSource) {
@@ -4231,29 +4237,49 @@ var ShaderFactory = /*#__PURE__*/ function() {
     ShaderProgram._counter = 0;
 })();
 
+/**
+ * @internal
+ * Shader pass type
+ */ var ShaderType;
+(function(ShaderType) {
+    ShaderType[ShaderType[/** init by glsl */ "Canonical"] = 0] = "Canonical";
+    ShaderType[ShaderType[/** init by shader-lab */ "ShaderLab"] = 1] = "ShaderLab";
+})(ShaderType || (ShaderType = {}));
+
 /**
  * Shader pass containing vertex and fragment source.
  */ var ShaderPass = /*#__PURE__*/ function(ShaderPart1) {
     _inherits(ShaderPass, ShaderPart1);
-    function ShaderPass(nameOrVertexSource, vertexSourceOrFragmentSource, fragmentSourceOrTags, tags) {
+    function ShaderPass(nameOrVertexSource, vertexSourceOrFragmentSourceOrCode, fragmentSourceOrTagsOrVertexEntry, fragmentEntryOrTags, tags) {
         var _this;
         _this = ShaderPart1.call(this) || this;
         /** @internal */ _this._shaderPassId = 0;
         /** @internal */ _this._renderStateDataMap = {};
         /** @internal */ _this._shaderProgramPools = [];
+        _this._platformMacros = [];
         _this._shaderPassId = ShaderPass._shaderPassCounter++;
-        if (typeof fragmentSourceOrTags === "string") {
+        _this._type = ShaderType.Canonical;
+        if (typeof fragmentEntryOrTags === "string") {
+            _this._name = nameOrVertexSource;
+            _this._shaderLabSource = vertexSourceOrFragmentSourceOrCode;
+            _this._vertexEntry = fragmentSourceOrTagsOrVertexEntry;
+            _this._fragmentEntry = fragmentEntryOrTags;
+            tags = _extends({
+                pipelineStage: PipelineStage.Forward
+            }, tags);
+            _this._type = ShaderType.ShaderLab;
+        } else if (typeof fragmentSourceOrTagsOrVertexEntry === "string") {
             _this._name = nameOrVertexSource;
-            _this._vertexSource = vertexSourceOrFragmentSource;
-            _this._fragmentSource = fragmentSourceOrTags;
-            tags = tags != null ? tags : {
+            _this._vertexSource = vertexSourceOrFragmentSourceOrCode;
+            _this._fragmentSource = fragmentSourceOrTagsOrVertexEntry;
+            tags = fragmentEntryOrTags != null ? fragmentEntryOrTags : {
                 pipelineStage: PipelineStage.Forward
             };
         } else {
             _this._name = "Default";
             _this._vertexSource = nameOrVertexSource;
-            _this._fragmentSource = vertexSourceOrFragmentSource;
-            tags = fragmentSourceOrTags != null ? fragmentSourceOrTags : {
+            _this._fragmentSource = vertexSourceOrFragmentSourceOrCode;
+            tags = fragmentSourceOrTagsOrVertexEntry != null ? fragmentSourceOrTagsOrVertexEntry : {
                 pipelineStage: PipelineStage.Forward
             };
         }
@@ -4271,9 +4297,51 @@ var ShaderFactory = /*#__PURE__*/ function() {
         if (shaderProgram) {
             return shaderProgram;
         }
+        if (this._type === ShaderType.Canonical) {
+            shaderProgram = this._getCanonicalShaderProgram(engine, macroCollection);
+        } else {
+            shaderProgram = this._compileShaderProgram(engine, macroCollection, this._vertexEntry, this._fragmentEntry);
+        }
+        shaderProgramPool.cache(shaderProgram);
+        return shaderProgram;
+    };
+    /**
+   * @internal
+   */ _proto._destroy = function _destroy() {
+        var shaderProgramPools = this._shaderProgramPools;
+        for(var i = 0, n = shaderProgramPools.length; i < n; i++){
+            shaderProgramPools[i]._destroy();
+        }
+        shaderProgramPools.length = 0;
+    };
+    /**
+   * Shader Lab compilation
+   */ _proto._compileShaderProgram = function _compileShaderProgram(engine, macroCollection, vertexEntry, fragmentEntry) {
+        var isWebGL2 = engine._hardwareRenderer.isWebGL2;
+        var macros = new Array();
+        ShaderMacro._getMacrosElements(macroCollection, macros);
+        this._platformMacros.length = 0;
+        if (engine._hardwareRenderer.canIUse(GLCapabilityType.shaderTextureLod)) {
+            this._platformMacros.push("HAS_TEX_LOD");
+        }
+        if (engine._hardwareRenderer.canIUse(GLCapabilityType.standardDerivatives)) {
+            this._platformMacros.push("HAS_DERIVATIVES");
+        }
+        if (isWebGL2) {
+            this._platformMacros.push("GRAPHICS_API_WEBGL2");
+        } else {
+            this._platformMacros.push("GRAPHICS_API_WEBGL1");
+        }
+        var start = performance.now();
+        var _Shader__shaderLab__parseShaderPass = Shader._shaderLab._parseShaderPass(this._shaderLabSource, vertexEntry, fragmentEntry, macros, isWebGL2 ? ShaderPlatformTarget.GLES300 : ShaderPlatformTarget.GLES100, this._platformMacros), vertex = _Shader__shaderLab__parseShaderPass.vertex, fragment = _Shader__shaderLab__parseShaderPass.fragment;
+        Logger.info("[ShaderLab compilation] cost time: " + (performance.now() - start) + "ms");
+        return new ShaderProgram(engine, vertex, fragment);
+    };
+    // TODO: remove it after migrate all shader to `ShaderLab`.
+    _proto._getCanonicalShaderProgram = function _getCanonicalShaderProgram(engine, macroCollection) {
         var isWebGL2 = engine._hardwareRenderer.isWebGL2;
-        var macroNameList = [];
-        ShaderMacro._getNamesByMacros(macroCollection, macroNameList);
+        var macroNameList = new Array();
+        ShaderMacro._getMacrosElements(macroCollection, macroNameList);
         var macroNameStr = ShaderFactory.parseCustomMacros(macroNameList);
         var versionStr = isWebGL2 ? "#version 300 es" : "#version 100";
         var graphicAPI = isWebGL2 ? "#define GRAPHICS_API_WEBGL2" : "#define GRAPHICS_API_WEBGL1";
@@ -4290,19 +4358,9 @@ var ShaderFactory = /*#__PURE__*/ function() {
             vertexSource = ShaderFactory.convertTo300(vertexSource);
             fragmentSource = ShaderFactory.convertTo300(fragmentSource, true);
         }
-        shaderProgram = new ShaderProgram(engine, vertexSource, fragmentSource);
-        shaderProgramPool.cache(shaderProgram);
+        var shaderProgram = new ShaderProgram(engine, vertexSource, fragmentSource);
         return shaderProgram;
     };
-    /**
-   * @internal
-   */ _proto._destroy = function _destroy() {
-        var shaderProgramPools = this._shaderProgramPools;
-        for(var i = 0, n = shaderProgramPools.length; i < n; i++){
-            shaderProgramPools[i]._destroy();
-        }
-        shaderProgramPools.length = 0;
-    };
     return ShaderPass;
 }(ShaderPart);
 (function() {
@@ -5006,45 +5064,44 @@ __decorate([
             if (!Shader._shaderLab) {
                 throw "ShaderLab has not been set up yet.";
             }
-            var shaderInfo = Shader._shaderLab.parseShader(nameOrShaderSource);
-            if (shaderMap[shaderInfo.name]) {
-                console.error('Shader named "' + shaderInfo.name + '" already exists.');
+            var shaderContent = Shader._shaderLab._parseShaderContent(nameOrShaderSource);
+            if (shaderMap[shaderContent.name]) {
+                console.error('Shader named "' + shaderContent.name + '" already exists.');
                 return;
             }
-            var subShaderList = shaderInfo.subShaders.map(function(subShaderInfo) {
-                var passList = subShaderInfo.passes.map(function(passInfo) {
-                    if (typeof passInfo === "string") {
+            var subShaderList = shaderContent.subShaders.map(function(subShaderContent) {
+                var passList = subShaderContent.passes.map(function(passInfo) {
+                    if (passInfo.isUsePass) {
                         var _Shader_find_subShaders_find, _Shader_find;
                         // Use pass reference
-                        var paths = passInfo.split("/");
+                        var paths = passInfo.name.split("/");
                         return (_Shader_find = Shader.find(paths[0])) == null ? void 0 : (_Shader_find_subShaders_find = _Shader_find.subShaders.find(function(subShader) {
                             return subShader.name === paths[1];
                         })) == null ? void 0 : _Shader_find_subShaders_find.passes.find(function(pass) {
                             return pass.name === paths[2];
                         });
                     }
-                    var shaderPass = new ShaderPass(passInfo.name, passInfo.vertexSource, passInfo.fragmentSource, passInfo.tags);
+                    var shaderPassContent = new ShaderPass(passInfo.name, passInfo.contents, passInfo.vertexEntry, passInfo.fragmentEntry, passInfo.tags);
                     var renderStates = passInfo.renderStates;
                     var renderState = new RenderState();
-                    shaderPass._renderState = renderState;
+                    shaderPassContent._renderState = renderState;
                     // Parse const render state
-                    var constRenderStateInfo = renderStates[0];
-                    for(var k in constRenderStateInfo){
-                        Shader._applyConstRenderStates(renderState, parseInt(k), constRenderStateInfo[k]);
+                    var constantMap = renderStates.constantMap, variableMap = renderStates.variableMap;
+                    for(var k in constantMap){
+                        Shader._applyConstRenderStates(renderState, parseInt(k), constantMap[k]);
                     }
                     // Parse variable render state
-                    var variableRenderStateInfo = renderStates[1];
                     var renderStateDataMap = {};
-                    for(var k1 in variableRenderStateInfo){
-                        renderStateDataMap[k1] = ShaderProperty.getByName(variableRenderStateInfo[k1]);
+                    for(var k1 in variableMap){
+                        renderStateDataMap[k1] = ShaderProperty.getByName(variableMap[k1]);
                     }
-                    shaderPass._renderStateDataMap = renderStateDataMap;
-                    return shaderPass;
+                    shaderPassContent._renderStateDataMap = renderStateDataMap;
+                    return shaderPassContent;
                 });
-                return new SubShader(shaderInfo.name, passList, subShaderInfo.tags);
+                return new SubShader(subShaderContent.name, passList, subShaderContent.tags);
             });
-            shader = new Shader(shaderInfo.name, subShaderList);
-            shaderMap[shaderInfo.name] = shader;
+            shader = new Shader(shaderContent.name, subShaderList);
+            shaderMap[shaderContent.name] = shader;
             return shader;
         } else {
             if (shaderMap[nameOrShaderSource]) {
@@ -8134,6 +8191,14 @@ var /**
     MSAASamples[MSAASamples[/** Multi-sample anti-aliasing with 8 samples. */ "EightX"] = 8] = "EightX";
 })(MSAASamples || (MSAASamples = {}));
 
+/**
+ * The strategy to use when a shader replacement fails.
+ */ var ReplacementFailureStrategy;
+(function(ReplacementFailureStrategy) {
+    ReplacementFailureStrategy[ReplacementFailureStrategy[/** Keep the original shader. */ "KeepOriginalShader"] = 0] = "KeepOriginalShader";
+    ReplacementFailureStrategy[ReplacementFailureStrategy[/** Do not render. */ "DoNotRender"] = 1] = "DoNotRender";
+})(ReplacementFailureStrategy || (ReplacementFailureStrategy = {}));
+
 var _Camera;
 var MathTemp = function MathTemp() {
 };
@@ -8183,6 +8248,7 @@ var Camera = (_Camera = /*#__PURE__*/ function(Component1) {
         /** @internal */ _this._virtualCamera = new VirtualCamera();
         /** @internal */ _this._replacementShader = null;
         /** @internal */ _this._replacementSubShaderTag = null;
+        /** @internal */ _this._replacementFailureStrategy = null;
         /** @internal */ _this._cameraIndex = -1;
         _this._priority = 0;
         _this._shaderData = new ShaderData(ShaderDataGroup.Camera);
@@ -8362,6 +8428,7 @@ var Camera = (_Camera = /*#__PURE__*/ function(Component1) {
         context.virtualCamera = virtualCamera;
         context.replacementShader = this._replacementShader;
         context.replacementTag = this._replacementSubShaderTag;
+        context.replacementFailureStrategy = this._replacementFailureStrategy;
         // compute cull frustum.
         if (this.enableFrustumCulling && this._frustumChangeFlag.flag) {
             this._frustum.calculateFromMatrix(virtualCamera.viewProjectionMatrix);
@@ -8381,15 +8448,18 @@ var Camera = (_Camera = /*#__PURE__*/ function(Component1) {
         this._renderPipeline.render(context, cubeFace, mipLevel, clearMask);
         this._engine._renderCount++;
     };
-    _proto.setReplacementShader = function setReplacementShader(shader, replacementTag) {
+    _proto.setReplacementShader = function setReplacementShader(shader, replacementTag, failureStrategy) {
+        if (failureStrategy === void 0) failureStrategy = ReplacementFailureStrategy.KeepOriginalShader;
         this._replacementShader = shader;
         this._replacementSubShaderTag = typeof replacementTag === "string" ? ShaderTagKey.getByName(replacementTag) : replacementTag;
+        this._replacementFailureStrategy = failureStrategy;
     };
     /**
    * Reset and clear the replacement shader.
    */ _proto.resetReplacementShader = function resetReplacementShader() {
         this._replacementShader = null;
         this._replacementSubShaderTag = null;
+        this._replacementFailureStrategy = null;
     };
     /**
    * @inheritdoc
@@ -8503,7 +8573,7 @@ var Camera = (_Camera = /*#__PURE__*/ function(Component1) {
         this._checkMainCanvasAntialiasWaste();
     };
     _proto._checkMainCanvasAntialiasWaste = function _checkMainCanvasAntialiasWaste() {
-        if (this.independentCanvasEnabled && Vector4.equals(this._viewport, PipelineUtils.defaultViewport)) {
+        if (this._phasedActiveInScene && this.independentCanvasEnabled && Vector4.equals(this._viewport, PipelineUtils.defaultViewport)) {
             Logger.warn("Camera use independent canvas and viewport cover the whole screen, it is recommended to disable antialias, depth and stencil to save memory when create engine.");
         }
     };
@@ -10197,6 +10267,7 @@ var /**
                             break;
                         }
                     }
+                    context.replacementFailureStrategy === ReplacementFailureStrategy.KeepOriginalShader && this.pushRenderElementByType(renderElement, subRenderElement, materialSubShader.passes, renderStates);
                 } else {
                     this.pushRenderElementByType(renderElement, subRenderElement, replacementSubShaders[0].passes, renderStates);
                 }
@@ -23341,7 +23412,7 @@ ShaderPool.init();
    */ _proto._initialize = function _initialize(configuration) {
         var _this = this;
         var shaderLab = configuration.shaderLab, physics = configuration.physics;
-        if (shaderLab) {
+        if (shaderLab && !Shader._shaderLab) {
             Shader._shaderLab = shaderLab;
         }
         var initializePromises = new Array();
@@ -25280,6 +25351,9 @@ var TonemappingEffect = /*#__PURE__*/ function() {
  */ var _PostProcessManager = /*#__PURE__*/ function() {
     function _PostProcessManager(scene) {
         this.scene = scene;
+        this./**
+   * Whether the post process manager is active.
+   */ isActive = true;
         var uberShader = Shader.find(_PostProcessManager.UBER_SHADER_NAME);
         var uberMaterial = new Material(scene.engine, uberShader);
         var depthState = uberMaterial.renderState.depthState;
@@ -25313,7 +25387,7 @@ var TonemappingEffect = /*#__PURE__*/ function() {
             get: /**
    * Whether has active post process effect.
    */ function get() {
-                return this._bloomEffect.enabled || this._tonemappingEffect.enabled;
+                return this.isActive && (this._bloomEffect.enabled || this._tonemappingEffect.enabled);
             }
         }
     ]);
@@ -34105,5 +34179,5 @@ var cacheDir = new Vector3();
     return CubeProbe;
 }(Probe);
 
-export { AmbientLight, AnimationArrayCurve, AnimationBoolCurve, AnimationClip, AnimationClipCurveBinding, AnimationColorCurve, AnimationCurve, AnimationEvent, AnimationFloatArrayCurve, AnimationFloatCurve, AnimationQuaternionCurve, AnimationRectCurve, AnimationRefCurve, AnimationStringCurve, AnimationVector2Curve, AnimationVector3Curve, AnimationVector4Curve, Animator, AnimatorConditionMode, AnimatorController, AnimatorControllerLayer, AnimatorCullingMode, AnimatorLayerBlendingMode, AnimatorLayerMask, AnimatorState, AnimatorStateMachine, AnimatorStateTransition, AssetPromise, AssetType, Background, BackgroundMode, BackgroundTextureFillMode, BaseMaterial, BasicRenderPipeline, BlendFactor, BlendMode, BlendOperation, BlendShape, BlendShapeFrame, BlendState, BlinnPhongMaterial, BloomDownScaleMode, BloomEffect, BoolUpdateFlag, BoxColliderShape, BoxShape, Buffer, BufferBindFlag, BufferMesh, BufferUsage, BufferUtil, Burst, Camera, CameraClearFlags, CameraType, Canvas, CapsuleColliderShape, CharacterController, CircleShape, ClearableObjectPool, CloneManager, Collider, ColliderShape, ColliderShapeUpAxis, CollisionDetectionMode, ColorOverLifetimeModule, ColorSpace, ColorWriteMask, CompareFunction, Component, ConeEmitType, ConeShape, ContentRestorer, ControllerCollisionFlag, ControllerNonWalkableMode, CubeProbe, CullMode, CurveKey, DataType, DependentMode, DepthState, DepthTextureMode, DiffuseMode, DirectLight, Downsampling, DynamicCollider, DynamicColliderConstraints, EmissionModule, Engine, EngineObject, Entity, EventDispatcher, FixedJoint, FogMode, Font, FontStyle, GLCapabilityType, GradientAlphaKey, GradientColorKey, HemisphereShape, HingeJoint, HitResult, IndexBufferBinding, IndexFormat, InputManager, InterpolationType, Joint, JointLimits, JointMotor, Keyframe, Keys, Layer, Light, Loader, Logger, MSAASamples, MainModule, Material, Mesh, MeshRenderer, MeshTopology, ModelMesh, OverflowMode, PBRBaseMaterial, PBRMaterial, PBRSpecularMaterial, ParticleCompositeCurve, ParticleCompositeGradient, ParticleCurve, ParticleCurveMode, ParticleGenerator, ParticleGradient, ParticleGradientMode, ParticleMaterial, ParticleRenderMode, ParticleRenderer, ParticleScaleMode, ParticleShapeArcMode, ParticleShapeType, ParticleSimulationSpace, ParticleStopMode, PhysicsMaterial, PhysicsMaterialCombineMode, PhysicsScene, PipelineStage, PlaneColliderShape, Platform, PointLight, Pointer, PointerButton, PointerPhase, Primitive, PrimitiveMesh, Probe, RasterState, ReferResource, RenderBufferDepthFormat, RenderFace, RenderQueue, RenderQueueType, RenderState, RenderStateElementKey as RenderStateDataKey, RenderTarget, RenderTargetBlendState, Renderer, ResourceManager, ReturnableObjectPool, RotationOverLifetimeModule, Scene, SceneManager, Script, SetDataOptions, Shader, ShaderData, ShaderFactory, ShaderLib, ShaderMacro, ShaderMacroCollection, ShaderPass, ShaderProperty, ShaderPropertyType, ShaderTagKey, ShadowCascadesMode, ShadowResolution, ShadowType, SizeOverLifetimeModule, Skin, SkinnedMeshRenderer, Sky, SkyBoxMaterial, SkyProceduralMaterial, SphereColliderShape, SphereShape, SpotLight, SpringJoint, Sprite, SpriteAtlas, SpriteDrawMode, SpriteMask, SpriteMaskInteraction, SpriteMaskLayer, SpriteRenderer, SpriteTileMode, StateMachineScript, StaticCollider, StencilOperation, StencilState, SubMesh, SubPrimitive, SubShader, SunMode, SystemInfo, TextHorizontalAlignment, TextRenderer, TextUtils, TextVerticalAlignment, Texture, Texture2D, Texture2DArray, TextureCoordinate, TextureCube, TextureCubeFace, TextureDepthCompareFunction, TextureFilterMode, TextureFormat, TextureSheetAnimationModule, TextureUsage, TextureWrapMode, Time, TonemappingEffect, TonemappingMode, TrailMaterial, TrailRenderer, Transform, UnlitMaterial, Utils, VelocityOverLifetimeModule, VertexAttribute, VertexBufferBinding, VertexElement, VertexElementFormat, WrapMode, XRManager, _PostProcessManager, assignmentClone, deepClone, dependentComponents, ignoreClone, request, resourceLoader, shallowClone };
+export { AmbientLight, AnimationArrayCurve, AnimationBoolCurve, AnimationClip, AnimationClipCurveBinding, AnimationColorCurve, AnimationCurve, AnimationEvent, AnimationFloatArrayCurve, AnimationFloatCurve, AnimationQuaternionCurve, AnimationRectCurve, AnimationRefCurve, AnimationStringCurve, AnimationVector2Curve, AnimationVector3Curve, AnimationVector4Curve, Animator, AnimatorConditionMode, AnimatorController, AnimatorControllerLayer, AnimatorCullingMode, AnimatorLayerBlendingMode, AnimatorLayerMask, AnimatorState, AnimatorStateMachine, AnimatorStateTransition, AssetPromise, AssetType, Background, BackgroundMode, BackgroundTextureFillMode, BaseMaterial, BasicRenderPipeline, BlendFactor, BlendMode, BlendOperation, BlendShape, BlendShapeFrame, BlendState, BlinnPhongMaterial, BloomDownScaleMode, BloomEffect, BoolUpdateFlag, BoxColliderShape, BoxShape, Buffer, BufferBindFlag, BufferMesh, BufferUsage, BufferUtil, Burst, Camera, CameraClearFlags, CameraType, Canvas, CapsuleColliderShape, CharacterController, CircleShape, ClearableObjectPool, CloneManager, Collider, ColliderShape, ColliderShapeUpAxis, CollisionDetectionMode, ColorOverLifetimeModule, ColorSpace, ColorWriteMask, CompareFunction, Component, ConeEmitType, ConeShape, ContentRestorer, ControllerCollisionFlag, ControllerNonWalkableMode, CubeProbe, CullMode, CurveKey, DataType, DependentMode, DepthState, DepthTextureMode, DiffuseMode, DirectLight, Downsampling, DynamicCollider, DynamicColliderConstraints, EmissionModule, Engine, EngineObject, Entity, EventDispatcher, FixedJoint, FogMode, Font, FontStyle, GLCapabilityType, GradientAlphaKey, GradientColorKey, HemisphereShape, HingeJoint, HitResult, IndexBufferBinding, IndexFormat, InputManager, InterpolationType, Joint, JointLimits, JointMotor, Keyframe, Keys, Layer, Light, Loader, Logger, MSAASamples, MainModule, Material, Mesh, MeshRenderer, MeshTopology, ModelMesh, OverflowMode, PBRBaseMaterial, PBRMaterial, PBRSpecularMaterial, ParticleCompositeCurve, ParticleCompositeGradient, ParticleCurve, ParticleCurveMode, ParticleGenerator, ParticleGradient, ParticleGradientMode, ParticleMaterial, ParticleRenderMode, ParticleRenderer, ParticleScaleMode, ParticleShapeArcMode, ParticleShapeType, ParticleSimulationSpace, ParticleStopMode, PhysicsMaterial, PhysicsMaterialCombineMode, PhysicsScene, PipelineStage, PlaneColliderShape, Platform, PointLight, Pointer, PointerButton, PointerPhase, Primitive, PrimitiveMesh, Probe, RasterState, ReferResource, RenderBufferDepthFormat, RenderFace, RenderQueue, RenderQueueType, RenderState, RenderStateElementKey as RenderStateDataKey, RenderTarget, RenderTargetBlendState, Renderer, ReplacementFailureStrategy, ResourceManager, ReturnableObjectPool, RotationOverLifetimeModule, Scene, SceneManager, Script, SetDataOptions, Shader, ShaderData, ShaderFactory, ShaderLib, ShaderMacro, ShaderMacroCollection, ShaderPass, ShaderPlatformTarget, ShaderProperty, ShaderPropertyType, ShaderTagKey, ShadowCascadesMode, ShadowResolution, ShadowType, SizeOverLifetimeModule, Skin, SkinnedMeshRenderer, Sky, SkyBoxMaterial, SkyProceduralMaterial, SphereColliderShape, SphereShape, SpotLight, SpringJoint, Sprite, SpriteAtlas, SpriteDrawMode, SpriteMask, SpriteMaskInteraction, SpriteMaskLayer, SpriteRenderer, SpriteTileMode, StateMachineScript, StaticCollider, StencilOperation, StencilState, SubMesh, SubPrimitive, SubShader, SunMode, SystemInfo, TextHorizontalAlignment, TextRenderer, TextUtils, TextVerticalAlignment, Texture, Texture2D, Texture2DArray, TextureCoordinate, TextureCube, TextureCubeFace, TextureDepthCompareFunction, TextureFilterMode, TextureFormat, TextureSheetAnimationModule, TextureUsage, TextureWrapMode, Time, TonemappingEffect, TonemappingMode, TrailMaterial, TrailRenderer, Transform, UnlitMaterial, Utils, VelocityOverLifetimeModule, VertexAttribute, VertexBufferBinding, VertexElement, VertexElementFormat, WrapMode, XRManager, _PostProcessManager, assignmentClone, deepClone, dependentComponents, ignoreClone, request, resourceLoader, shallowClone };
 //# sourceMappingURL=module.js.map